The data layer for production AI agents.
Production agents need more than prompts and orchestration. They need persistent memory, governed access to operational data, reusable tools, prompt/version visibility, and traces you can inspect when something goes wrong. Increasingly, they also need to run where the work actually happens: on a phone, a kiosk, a field device, or a server room with no reliable uplink.
The Couchbase AI Data Plane brings those pieces together on Couchbase’s JSON-native, distributed data platform so teams can move from AI prototypes to production without stitching together separate stores for memory, vectors, documents, tools, and observability. It runs the same way whether your agent is talking to a managed cloud cluster or to an embedded database on a disconnected device.
Persistent short-term and long-term memory for AI agents.
Agent Memory helps agents retain context across sessions, restarts, users, and frameworks. It supports conversational memory, semantic recall, TTL-based memory decay, timestamped conflict handling, point-in-time retrieval, and OIDC/OAuth2 access control.
Validated with:
- LangGraph
- CrewAI
- LlamaIndex
- Strands
Standardized agent access to Couchbase data through the Model Context Protocol.
The Couchbase MCP Server lets MCP-compatible agents query and interact with Couchbase without custom integration code for every agent or framework.
A governed place for agent tools, prompts, and traces. Agent Catalog stores tool metadata, prompt metadata, and end-to-end agent traces in Couchbase so teams can inspect agent behavior with SQL++. Procedure: Querying Traces
You can query traces from the Agent Catalog using the Query Service or Capella Analytics.
In the Capella UI, on the Operational page, click the name of your cluster. Go to Data Tools > Query. Query one of the following views: Sessions View: For debugging multi-agent systems and agent handoff information. Exchanges View: For events between user input and agent response. ToolInvocations View: For tool calls and results (requires configuration to associate tool calls with results).
/* Example: most recent tool invocation record: */
SELECT ti.sid, ti.root, ti.tool_call, ti.tool_result
FROM `[BUCKET_NAME]`.`[SCOPE_NAME]`.ToolInvocations ti
ORDER BY ti.tool_result.timestamp DESC
LIMIT 1;
For comprehensive query examples and schema details, refer to the Agent Tracer documentation.
Agents don't only run in a data center. As they become part of the operational workforce, they show up on mobile devices, in retail stores, on factory floors, in vehicles, and in other environments where connectivity is intermittent or absent. The AI Data Plane extends to these environments so agents can access replicated data, retain memory, and perform local vector search (even while disconnected) then reconcile automatically once connectivity returns.
This is powered by Couchbase's mobile and edge stack:
Couchbase Lite: an embeddable database with SQL++, full-text search, and on-device vector search, for iOS, Android, .NET, Java, JavaScript, C, and C++. Capella App Services: a fully managed backend that provides bi-directional sync between Capella and Couchbase Lite-enabled apps, with authentication, channel-based data routing, and automatic conflict resolution. Sync Gateway: the self-managed alternative to App Services, for cloud-to-edge sync you host and operate yourself. Edge Server: a lightweight sync and data node for resource-constrained environments (single-board computers, kiosks, on-prem gateways) that don't need a full Couchbase Server deployment. Peer-to-peer sync: direct device-to-device replication (including over Bluetooth) with no internet or central server required, so agents keep working when every other layer is offline.
A minimal example connecting an embedded Couchbase Lite database to a Capella App Endpoint so an on-device agent can pull the operational data and memory it needs:
// Swift
let targetURL = URL(string: "wss://10.1.1.12:8092/travel-sample")
let targetEndpoint = URLEndpoint(url: targetURL!)
let collConfig = CollectionConfiguration(collection: self.collection)
var config = ReplicatorConfiguration(collections: [collConfig], target: targetEndpoint)
config.replicatorType = .pushAndPull
config.continuous = true
config.authenticator = BasicAuthenticator(username: "john", password: "pass")
replicator = Replicator(config: config)
replicator.start()
Once synced locally, an on-device agent can run vector search directly against Couchbase Lite for RAG or semantic recall without a network round trip: useful for field service copilots, retail associate assistants, or any agent that has to keep working when the connection doesn't.
Couchbase combines operational data, JSON documents, key-value access, SQL++, full-text search, vector search, eventing, mobile sync, and analytics in one platform.
For AI agents, that means you can keep memory, context, operational data, and governance closer together instead of spreading them across disconnected services. And it extends that same governed data layer from cloud to edge to device, instead of building a separate stack for offline and mobile scenarios.
Run where your data needs to live:
- Capella managed cloud
- Self-managed Couchbase Server
- Kubernetes or bare metal
- Hybrid environments
- Edge and mobile with Couchbase Lite
- Air-gapped environments
- Agents moving from prototype to production
- RAG apps that need operational filters plus vector search
- Teams standardizing agent access to enterprise data
- Apps that need persistent memory across sessions
- Regulated or distributed environments where governance matters
- Edge and mobile AI apps that need local data access
Couchbase Capella: sign up for managed Capella
Couchbase docs: full documentation
Developer portal: tutorials, guides, and sample apps
Couchbase MCP Server: standardized agent access via MCP
Couchbase SDKs: server-side language SDKs
Couchbase Mobile & Edge docs: Couchbase Lite, App Services, Sync Gateway, and Edge Server