Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
Merge remote-tracking branch 'origin/cheaper-pool-checkout' into scale-core
Abel Dantasdbd15734a156
diff --cc CHANGELOG.mdindex 2d1cb08ef,3fd9bdef3..6a585ac1a--- a/CHANGELOG.md+++ b/CHANGELOG.md@@@ -159,83 -159,12 +159,89 @@@ version of their own to them without alcompares it only when someone signs in.#### Changed+- **Workspaces belong to organizations. Upgrade by replacing every pod, and+ downgrade the database before rolling back.** Every existing workspace gets+ an organization of its own, and its owners become the organization's admins.+ An organization admin administers every workspace in it without being added+ to each. A release from before organizations doesn't know about organization+ admins: if old and new pods serve together during a rolling update, or after+ a rollback that keeps the new database, an owner removed from a workspace by+ an old pod is still the organization's admin and can come back into it. So+ for this release, replace every switch-core pod at once rather than rolling+ them, and to roll back, first downgrade the database to the revision before+ `238c68b7306e` (`alembic downgrade 238c68b7306e-1`), then start the older+ release.+- **The statements every message write costs run on asyncpg directly.**+ Taking the room's lock, reading its head, storing the agents' own events+ and reading the room's agent members again under the lock go straight to+ asyncpg on the transaction's connection (`db/raw.py`), as the delivery+ reads do, rather than through SQLAlchemy's execution.+- **The two reads behind every delivery run on asyncpg directly.** A+ stream reads an agent's events, and counts its unread messages, for every+ event it delivers, and under load SQLAlchemy's work around each statement+ cost more than Postgres took to run it. `db/raw.py` runs a statement+ SQLAlchemy compiled once on the session's own asyncpg connection, in its+ transaction and under its tenant, with SQLAlchemy's type conversions and+ timed into `db.query.duration` as every other statement is.+- **Pods start in seconds again with many rooms.** Every process checks at+ startup that each room has its clients, under a lock that lets one+ process at a time through, and read each room on its own to do it. With+ tens of thousands of rooms that took about 100 seconds, so processes+ starting together were restarted while they waited. Rooms are now read a+ thousand at a time.+- **Idle agents behind a controller cost the database far less.** A+ controller stream's pass, including the one after every idle interval,+ read each of its agents' events in a session of its own; it now reads all+ their heads in one query and reads only the agents with something new. And+ each process's 30-second re-check of controllers held by another process+ read every agent's rooms with a query of its own, which grew with+ processes times agents; it is now one query per controller.+- **A delivery to an agent behind a controller takes two database+ transactions instead of four.** The controller's stream read the heads of+ all its agents to find the work, again after delivering, and again before+ waiting. It now reads them once a pass, and an event that arrives after+ that read wakes the stream for the next pass.+- **A controller keeps its socket when a delivery pass cannot get a+ database connection.** When a pod was too busy to hand its streams a+ connection within the pool timeout, the controller's stream ended and its+ socket closed, and every agent on it reconnected, which needs more of+ what was short. The pass is now tried again after a short wait, doubling+ to 5 seconds, and the socket closes only if it is still failing after a+ minute.+- **Switch's own reader is woken only by commands.** The process that holds+ a workspace's admin client read every row of every room to find the+ `!command` rows it answers. A new row's announcement now names its type,+ and that reader is woken for command rows only and reads only those, from+ a partial index on them. Its warnings for tags nobody can answer are+ already posted by the process that writes the message.+- **The heads-up for tagging an agent that isn't in the room comes from the+ process that wrote the message, and costs nothing when every name tagged+ is one of the room's agents.** The admin's consumer, which reads every+ message in a workspace on one process, checked each message with an `@`:+ two database sessions and a lookup for every name tagged. Under load that+ one process fell behind the rest. The check now runs once a message has+ committed, on whichever process wrote it, and only when the message tags+ a name that is none of the room's agents (a role, a person, an agent not+ in the room). The warnings read as before.+- **The server spends less CPU on its event loop and on finding the agent+ sending a message.** It now runs on uvloop wherever uvloop is installed,+ which is every platform but Windows. Finding the actor of the agent+ sending a message no longer looks through every client's actor, and+ compiled mention patterns are kept per name. In a CPU profile under+ message load the event loop's own work was about 15% of a pod's CPU and+ the actor lookup about 3%.+- **Creating a room or an agent no longer looks through every running+ client.** Every process keeps an actor for every client, and finding a+ workspace's admin, or the actor of an agent registered in another process+ a moment before, read all of them. Each is now found from an index of the+ running clients by type and by agent. While 10,000 agents were being+ created, these lookups took about 11% of a process's CPU in a profile.+ - **Each database transaction costs the server a little less.** Binding the+ workspace to a transaction built and compiled the same statement every+ time; it is now sent to the driver as it is. And timing who holds a pooled+ connection worked out the borrower's name and a short stack on every+ checkout; the name is now kept per function, and the stack is written out+ only for a hold long enough to log.- **An agent's stream reads in one database session per pass, and pooledconnections are no longer pinged before use.** A pass that delivered amessage opened a session for each of its reads, six pool checkouts and sixdiff --cc core/switch_core/db/tenant_session.pyindex 401647dac,2df556491..31811993f--- a/core/switch_core/db/tenant_session.py+++ b/core/switch_core/db/tenant_session.py@@@ -138,6 -135,9 +138,10 @@@ def register_tenant_session_hook() -> N_registered = True+ _SET_TENANT = "SELECT set_config('app.tenant_id', $1, true)"++_SET_ORGANIZATION = "SELECT set_config('app.organization_id', $1, true)"++def _set_tenant_on_begin(session: Session, transaction: SessionTransaction, connection: Connection) -> None:@@@ -157,17 -156,11 +161,13 @@@# with nothing" is exactly what the drift check needs to be able to tell# apart from "no transaction has begun yet".session.info[_STAMPED] = tenant_id- if tenant_id is None:- return- # Sent to the driver as it is: a `text()` construct would be built and+ session.info[_STAMPED_ORGANIZATION] = organization_id++ # Sent to the driver as they are: a `text()` construct would be built and+ # compiled again for every transaction, which is every session.- connection.exec_driver_sql(_SET_TENANT, (tenant_id,))+ if tenant_id is not None:- connection.execute(- text("SELECT set_config('app.tenant_id', :tenant_id, true)"),- {"tenant_id": tenant_id},- )++ connection.exec_driver_sql(_SET_TENANT, (tenant_id,))+ if organization_id is not None:- connection.execute(- text("SELECT set_config('app.organization_id', :organization_id, true)"),- {"organization_id": organization_id},- )++ connection.exec_driver_sql(_SET_ORGANIZATION, (organization_id,))def _forget_the_stamp(session: Session, transaction: SessionTransaction) -> None: