Forem: Brian King

Couchbase "Spooktacular Scale" Weekly Updates - October 31, 2025

Brian King — Fri, 31 Oct 2025 17:08:11 +0000

It’s Halloween 🎃, and Couchbase has been brewing some powerful potions in its data cauldron. From AI that whispers insights faster than a ghost through the wires, to event-driven migrations that move data smoother than a vampire’s cloak — this week’s updates are frightfully good for developers. So grab your pumpkin-spiced latte and let’s raise the documents together!

🧠 Couchbase 8.0: The Unified Data Platform Awakens
Couchbase 8.0 has risen from the lab, and it’s a monster release built for AI-powered apps that demand hyperscale speed. With new vector indexing capabilities for lightning-fast semantic search and upgrades across every core service, it’s engineered to handle both your classic workloads and next-gen AI integrations. Whether in Capella, on-prem, or at the edge, Couchbase 8.0 is ready to power your most ambitious (and spooky-smart) applications. Find out more>>
⚡ Event-Driven Data Migration with Eventing
Migrating data doesn’t have to feel like resurrecting zombies. With Couchbase’s Eventing Service, developers can now perform real-time transformations as documents move from one collection to another. Think of it as migration magic: rename fields, flatten structures, and enrich your data the moment it arrives. No bulky ETL pipelines, no dark rituals — just clean, transformed data ready for production in Capella. Learn the pattern >>
🌐 Get Started with the Data API
When you need something fast and simple, the Couchbase Data API lets you work directly with data over REST — no SDKs, no setup, just clean HTTP calls. It’s perfect for serverless environments, microservices, or quick experiments that call for flexibility. Enable the API in Capella, grab your endpoint, and start making requests faster than you can say “curl -X POST.” Try it out >>
🤖 Ask AI in Capella (Public Preview)
Ever wished your database documentation could talk back? Now it can. The new Ask AI feature in Capella is your built-in chat assistant that helps you find answers, navigate features, and learn best practices — all without leaving the platform. Whether you’re asking about vector indexing, query syntax, or setup steps, Ask AI is like having a helpful (and slightly supernatural) coworker by your side. Start chatting >>

That’s it for this week’s Couchbase Weekly for developers! 💥

What are you building with Couchbase? Got a project, demo, or tutorial to share? Drop it in the comments (or hit us up on Discord), and we might feature it in a future issue.

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - October 17, 2025

Brian King — Fri, 17 Oct 2025 20:23:27 +0000

It’s been one of those weeks where vectors, llamas, and mobile SDKs all walk into a database. From new books on vector search to fresh patterns for high-performance data access, one thing’s clear: if you’re building apps that live beyond the cloud, Couchbase is the best way forward for mobile and edge developers. Let’s get to it.

📘 Vector Search with JavaScript
Ben Greenberg’s new Pragmatic Programmers title, Vector Search with JavaScript guides developers through building intelligent, AI-powered search systems with Node.js. It’s a great read for anyone looking to blend embeddings and hybrid search into modern apps — including those powered by Couchbase’s flexible JSON and vector features. Get the book>>
🦙 Llamas, With a Chance of JSON
In Jacob Wood’s post the humble llama gets a shot at a starring role in structured data. A fun reminder that JSON, and Couchbase, can handle the weird and wonderful shapes data takes in the real world. Read the post >>
📱 Mobile That’s Here to Stay
Developers need mobile databases they can rely on — and Couchbase Mobile delivers. With on-device storage, full CRUD access, and built-in sync, Couchbase Lite and Sync Gateway keep your apps running anywhere, anytime. Check out the SDK comparison repo to see how Couchbase’s mobile SDK stacks up against Atlas SDK, and why it’s the future-proof choice for your next offline-first project. Dive in >>
⚡ Bulk Get Docs, the Efficient Way
The new blog post, Bulk Get Documents with Reactive or Async APIs, walks through efficient patterns for fetching many documents in parallel. Whether you’re using reactive streams or async futures, it’s a performance win for developers who want to do more with less latency. Get on in >>

That’s it for this week’s Couchbase Weekly for developers! 💥

What are you building with Couchbase? Got a project, demo, or tutorial to share? Drop it in the comments (or hit us up on Discord), and we might feature it in a future issue.

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - October 3, 2025

Brian King — Fri, 03 Oct 2025 17:16:23 +0000

Welcome to this week’s Couchbase updates! MongoDB’s Realm mobile sync has reached end-of-life, so we’re highlighting migration paths with Couchbase Mobile. We’ve also got a new Slow Query Analyzer to make tuning SQL++ queries painless, a guide to building AI agents with cagent + Couchbase, and plenty of ways to connect through our developer community and upcoming events.

🛡️ Realm/MongoDB Mobile EOL
MongoDB has ended support for Atlas Device Sync and Realm SDKs (Sept 30). If you’re using it, now’s the time to migrate. Couchbase Mobile offers JSON flexibility, SQL from cloud to device, vector search (even offline), peer-to-peer sync, and custom conflict resolution. Read more>>
🔍 Couchbase Query Analyzer (cb.fuj.io)
Tuning queries just got easier. The new Slow Query Analyzer visualizes completed requests, highlights bottlenecks, and suggests indexes. Paste JSON from system:completed_requests, explore insights, and export reports. Works with Couchbase Server 7.6+ and Capella. Try it >>
🤖 AI Agents with Couchbase MCP + cagent
Couchbase now integrates with cagent, a Docker-based AI agent framework. Using Model Context Protocol (MCP), agents can query Couchbase, summarize results, and power autonomous workflows. Quick to prototype, ready for production. See how >>
🌐 Community Pulse
There are many opportunities to participate in the Couchbase Developer Community including events, forums, and the Ambassador program. Share your projects, get support, and grow your voice. Get involved >>

That’s it for this week’s Couchbase Weekly for developers! 💥

What are you building with Couchbase? Got a project, demo, or tutorial to share? Drop it in the comments (or hit us up on Discord), and we might feature it in a future issue.

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - September 19, 2025

Brian King — Fri, 19 Sep 2025 19:57:24 +0000

Another week, another batch of goodness from around the Couchbase universe. Whether you’re here to geek out over cloning clusters like a sci-fi lab experiment, curious about wrangling production-ready AI agents that won’t spontaneously combust, or just hunting for your next learning rabbit hole — we’ve got you covered. Oh, and if you’re into live events (the comfy virtual kind), there’s one coming up you won’t want to miss.

🌱 Clone Couchbase Clusters for CI/CD On-Demand Ephemeral Environments
Ever wanted to spin up Couchbase clusters on demand, like test environments on tap? This blog walks through using Couchbase Shell + Nushell scripting to export your cluster structure and import it into new ones. Perfect for QA, CI/CD, or when you just want to feel like a wizard with infrastructure. Cluster up >>
🤖 ICYMI: Building Production-Ready AI Agents with Couchbase and Nebius AI
AI agents are shiny and exciting — but how do you make them stable enough to survive the chaos of production? This recap from a recent webinar dives into best practices for reliability, state management, and scaling. Think less “paperclip maximizer,” more “your new dependable coworker.” Get caught up >>
📺 Live Couchbase MCP Goodness
Circle this one on your calendar (or, more realistically, add it to your Google Calendar and immediately forget until the reminder pings). This session will show how to build AI agents with Couchbase MCP and give you a chance to pepper the speaker with questions. RSVP >>
📜 Couchbase Academy: An Upgraded Learning Experience
Same great content, same URL, better learning experiences all around! As of Sept. 1, we've upgraded Couchbase Academy to share the same stellar content with new additions around Couchbase Analytics, Couchbase AI Services, and more! We'll soon be offering contents and Learning Leaderboard capabilities, and each learner now has a customized Content progress, questions, and content requests. Learn more >>

That’s it for this week’s Couchbase Weekly for developers! 💥

What are you building with Couchbase? Got a project, demo, or tutorial to share? Drop it in the comments (or hit us up on Discord), and we might feature it in a future issue.

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - September 5, 2025

Brian King — Fri, 05 Sep 2025 15:58:08 +0000

Another week, another batch of awesome updates from the Couchbase universe! We’ve got everything from on-device plant whispering with AI, to smarter agents that actually get context, to prompt engineering hacks that will make your AI outputs feel less… well, robotic. And if that’s not enough, we’ll also peek into our ever-growing integration ecosystem—because who doesn’t love shiny new tools that make life easier?

🌱 PlantPal: A RAG-powered Plant ID App on iOS
Developer Evangelist Pulkit Midha built PlantPal, a Retrieval-Augmented Generation (RAG) iOS app that instantly identifies plants and provides care advice—entirely on-device. No internet, no photo uploads—just fast, private AI. Impressively, the app was shrunk from 800 MB to just 14 MB. The magic? Couchbase Lite Vector Search + MobileCLIP for image embedding, Core ML, and Apple’s on-device LLM frameworks. App walkthrough >>
🤖 Building Smarter Agents with Vector Search
This blog explores how Couchbase Vector Search empowers intelligent agents with semantic awareness. The article highlights real-time semantic retrieval and enhanced AI workflows. While centered on Couchbase's broader AI capabilities, it emphasizes how vector search underpins smarter, context-aware applications. Read the blog >>
✍️ Prompt Engineering: Techniques, Examples, and Tools
In this timely guide, Tyler Mitchell outlines prompt engineering—the craft of phrasing inputs to guide AI systems toward accurate, contextual, and useful outputs. Prominent use cases include content creation, code generation, customer support, and education. Benefits include improved accuracy, productivity gains, and broad domain applicability—alongside challenges like bias and scalability. Read now >>
🔌 Couchbase Integrations: Ecosystem Boost for Developers
Couchbase continues to expand its integration ecosystem with both official and community-supported connectors. Explore options ranging from vector storage, document loaders, and data streaming, to DevOps tools like Terraform, and real-time sync connectors such as Kafka and GlueSync—all designed to streamline your architecture and workflows. Explore integrations >>

Notable Integration Highlights:
- 🛠️ JetBrains IDE Plugin – Manage Couchbase clusters, documents, and run SQL++ queries directly within JetBrains IDEs like IntelliJ, WebStorm, PyCharm, DataGrip, and more. 👉 More details >>
- 💻 VS Code Extension – Enhanced integration for cluster management, document editing, SQL++ notebooks, migrations, and Capella iQ AI assistance—all in your VS Code editor. 👉 More details >>
- 🐍 LlamaIndex Integration – Powerful Python integration to load documents from Couchbase into LlamaIndex, flexible data loading via SQL++, and metadata customization—ideal for embedding workflows. 👉 More details >>
- 🧩 LangChain Integration – Seamlessly integrate Couchbase with LangChain for storing and retrieving embeddings in AI/ML pipelines—handling both structured and unstructured data. 👉 More details >>

That’s it for this week’s Couchbase Weekly for developers! 💥

What are you building with Couchbase? Got a project, demo, or tutorial to share? Drop it in the comments (or hit us up on Discord), and we might feature it in a future issue.

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - August 15, 2025

Brian King — Fri, 15 Aug 2025 14:28:55 +0000

We’re back with a fresh batch of Couchbase goodies! This week’s mix is all about sharper architecture, smoother integrations, and a real-world customer story that’s got performance gains written all over it. Grab your coffee, crack open that terminal, and let’s roll:

🚦 High Availability vs. Fault Tolerance – What’s the Difference?

Not all “always-on” setups are created equal. Learn how high availability helps you recover fast, while fault tolerance keeps your app humming even when things go sideways. Read now >>
💻 EF Core + Couchbase Integrations

From ASP.NET Core Identity to GraphQL (via Hot Chocolate) to OData—see how Couchbase’s EF Core provider plays nice with your favorite .NET tools. Unofficial, but powerful. See the examples >>
🔗 Fully Managed Connector for Confluent Cloud

No more wrangling infrastructure! Stream data between Couchbase and Confluent Cloud (both directions!) with a fully managed Sink & Source connector. Real-time, no deployment headaches. Learn more >>
📊 Enterprise Analytics for Self-Managed Deployments

A big product release this week. Zero-ETL ingestion. JSON-native. Up to 150× faster. And now, not just for Capella. Couchbase Enterprise Analytics just became your self-managed secret weapon. Get the details >>
🏋️ ButfitSeoul Levels Up with Couchbase

This fast-growing Korean fitness tech startup runs an online/offline fitness platform (TEAMBUTFIT + BUTFITGROUND) and scaled rapidly after the pandemic. Couchbase’s performance, offline sync, and scalability keep their experience seamless and resilient for every user, everywhere. Read the case study >>

💡Sign up for Capella Free Tier and follow us for future updates!

Couchbase Weekly Updates - August 8, 2025

Brian King — Fri, 08 Aug 2025 16:14:11 +0000

After a hiatus of a few weeks, we’re back with updates on fresh tools, insights, and integrations for developers. We’re excited to share Couchbase’s new support in the Google MCP Toolbox, a head-to-head look at SQL++ vs. Mongo’s Query API, and a framework for evaluating agentic AI workflows. Plus, we introduce a new project to halt pod evictions in Kubernetes for more stable stateful applications. Oh, and we won another award to round out a great week!

🧰 Announcing Couchbase Support in Google’s MCP Toolbox for Databases - As autonomous AI agents become more powerful and pervasive, developers need ways to securely and reliably connect these agents to operational and analytical data. Whether you’re building customer service agents, intelligent dashboards, or agentic workflows, data access is the backbone of intelligence. That’s why we’re excited to announce that Couchbase is now officially supported in the Google MCP Toolbox for Databases. Learn more >>
✚✚ Choosing the Right Query Language: SQL++ vs. Mongo - When you’re building apps, the query language you work with makes a big difference. It affects everything from performance to how quickly your team can ship features. In this post, we walk through a number of criteria and show how SQL++, used by Couchbase, and Mongo’s Query API (previously known as MQL) languages stack up. Whether you’re evaluating databases for a new project, or just curious about the differences between these two approaches, this should give you a clear picture of where each one shines and where it might fall short. Choose wisely >>
🤖 Evaluating Agentic AI Workflows - Agents and agentic pipelines are being built and released at an accelerated pace like never before. But how can we determine how good they are? Developing robust AI agent evaluation frameworks has become essential for several compelling reasons that we go through in this post. Read on >>
🪝 Rethinking Node Drains: A Webhook Based Approach to Graceful Pod Removal - Events like maintenance or resource pressure can trigger pod evictions in Kubernetes, which risk disrupting services if not handled carefully. The Eviction Reschedule Hook is an open source project that aims to address this issue by using Kubernetes Admission Controllers to intercept and reject eviction requests for operator-managed pods and act accordingly. Halt the eviction >>
🏆 Couchbase Mobile Wins at the DBTA Readers’ Choice Awards - Who doesn’t love to win an award? We always do, and once again Couchbase Mobile shines as voted by DBTA readers, winning the Best IoT Solution. We are honored and thankful. Share the win >>

Announcing Couchbase Support in Google’s MCP Toolbox for Databases

Brian King — Wed, 23 Jul 2025 21:56:28 +0000

Unlock real-time access for AI agents with SQL++ and the Model Context Protocol (MCP)

As autonomous AI agents become more powerful and pervasive, developers need ways to securely and reliably connect these agents to operational and analytical data. Whether you’re building customer service agents, intelligent dashboards, or agentic workflows, data access is the backbone of intelligence.

That’s why we’re excited to announce that Couchbase is now officially supported in the Google MCP Toolbox for Databases.

This integration empowers developers to accelerate the development of agentic AI applications by bridging the gap between Couchbase’s high-performance, flexible NoSQL database and the MCP standard for tool-based agent orchestration. By leveraging Couchbase within the MCP Toolbox, teams can unlock intelligent data-driven workflows that are secure, scalable, and context-aware. Developers no longer need to spend time building custom connectors or managing complex access logic. Now they can focus on building smarter agents that query and act on operational data with minimal friction. This integration brings the performance, flexibility, and real-time capabilities of Couchbase to the emerging ecosystem of Model Context Protocol (MCP)-compatible AI tools.

Why Couchbase + MCP Toolbox matters for developers

The Google MCP Toolbox for Databases acts as an MCP server , allowing AI agents to interact with structured data through declarative tool definitions, without the need to expose databases directly or write custom integration code for each use case.

By adding Couchbase support, developers gain:

- Rich document modeling with sub-document access and flexible schemas.
- Built-in scalability and sync for edge, mobile, and distributed applications.
- MCP compatibility , enabling AI agents to reason over and query Couchbase data via secure, standardized tool interfaces.

Now, agents can issue natural-language queries that get converted into SQL++ tool calls behind the scenes, without hardcoding logic, creating custom APIs, or exposing database credentials.

How it works

The Google MCP Toolbox for Databases is an open-source MCP server that connects AI orchestration layers (like LangChain, LangGraph, or Anthropic’s Claude) to database-backed tools.

To configure Couchbase access, you define your data sources and tools in a YAML config file:

Sample tools.yaml

sources:
  cb-orders:
    kind: couchbase

    connectionString: couchbase://localhost:8091
    bucket: orders_bucket

    scope: orders

    username: toolbox_user
    password: $CB_PASSWORD

tools:
  get-customer-orders:
    description: Retrieve recent orders for a specific customer by email.
    source: cb-orders
    query: |
      SELECT order_id, total, status, order_date
      FROM orders_bucket
      WHERE customer.email = $email
      ORDER BY order_date DESC
      LIMIT 10;
    parameters:
      - name: email
        type: string
        description: customer email

Once deployed, your AI agents can invoke get-customer-orders by passing the email parameter, and the MCP Toolbox will translate the request into a secure SQL++ query against Couchbase.

Agentic use cases for Couchbase + MCP

Conversational BI dashboards

Build agents that generate dynamic dashboards and metrics by querying Couchbase for business insights. Couchbase’s SQL++ support allows complex aggregations and JOINs, even across flexible schemas.

- Example: “What were the top 10 product categories last quarter by revenue?”

E-Commerce Agent Assistants

Serve product recommendations, inventory checks, and order histories from JSON documents in Couchbase. Support fast lookups and full-text search to guide users in real-time.

- Example: “Show me available trail running shoes under $120 in size 11.”

IoT and Edge Analytics

Couchbase Mobile and Sync Gateway bring real-time data from edge devices into Couchbase. Agents can analyze telemetry, spot anomalies, or initiate remediation workflows using SQL++ queries.

- Example: “List sensors with temperature fluctuations over 10 degrees in the past hour.”

Secure Customer Copilots

Build personalized agents that help users understand their own data—finances, activity, healthcare, etc.—by securely scoping SQL++ queries to their identity context.

- Example: “Summarize my recent transactions and categorize them.”

LangChain + Couchbase via MCP: integration example

Here’s how you can wire Couchbase tools into a LangChain agent via MCP Toolbox:

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

MCP_ENDPOINT = "http://localhost:8080"

tool_box = ToolboxClient(MCP_ENDPOINT)
toolbox_tools = toolbox_client.load_toolset("toolset_name")

llm = ChatOpenAI(
   model="gpt-4o",
   temperature=0.1,
   api_key=settings.openai_api_key
)
agent = create_react_agent(
    tools=toolbox_tools,
    model=llm,
    debug=True
)

agent.invoke( {"messages": [{"role": "user", "content": "Get the last few orders for alice@example.com."}]} )

Built for production

The MCP Toolbox for Databases offers production-grade features out of the box:

- Config-driven deployment with zero downtime
- Connection pooling and retry logic
- OAuth2 / OIDC auth for secure access
- OpenTelemetry support for metrics and traces
- Support for multiple databases from a single config

You can deploy the toolbox as a microservice alongside your orchestration layer (e.g. in GKE, Cloud Run, or Kubernetes Anywhere).

Get started

- Google MCP Toolbox for Databases (GitHub)
- Couchbase Developer Portal
- Deploy locally or in the cloud with Docker, Cloud Run, or Kubernetes

In summary

With this new integration, Couchbase joins the growing list of production-ready backends in the Google MCP ecosystem. Developers now have a fast, scalable, and secure way to enable AI agents to access NoSQL document data using standardized protocols.

This lowers the barrier to building intelligent applications that react in real-time to user inputs, contextual data, and live system states, all powered by Couchbase and governed by the open MCP standard.

The post Announcing Couchbase Support in Google’s MCP Toolbox for Databases appeared first on The Couchbase Blog.

3 EF Core Integrations That Work with Couchbase

Brian King — Wed, 16 Jul 2025 17:17:31 +0000

Couchbase’s new EF Core provider opens the door to some powerful .NET integrations: even ones traditionally tied to relational databases. This post walks through how Identity, GraphQL, and OData all work with Couchbase.

In this post, I’ll walk through three advanced EF Core integrations that I have successfully tested with Couchbase:

ASP.NET Core Identity
GraphQL (via Hot Chocolate)
OData

*Note: * These integrations are based on limited testing and are not officially supported (yet). Your mileage may vary, but so far, they show a lot of promise.

ASP.NET Core Identity

Microsoft.AspNetCore.Identity.EntityFrameworkCore provides a plug-and-play authentication and user management system for ASP.NET apps.

Couchbase’s EF Core provider works well with it. The only caveat is that you’ll need to make sure the proper collections exist first (like AspNetUsers, AspNetRoles, etc).

*Note: * You must create the following collections in advance: AspNetUsers, AspNetRoles, AspNetUserRoles, AspNetUserClaims, AspNetUserLogins, AspNetUserTokens, AspNetRoleClaims.

Example EF setup

public class AppDbContext : IdentityDbContext<ApplicationUser>
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        builder.Entity<ApplicationUser>().ToCouchbaseCollection(this, "AspNetUsers");
        builder.Entity<IdentityRole>().ToCouchbaseCollection(this, "AspNetRoles");
        builder.Entity<IdentityUserRole<string>>().ToCouchbaseCollection(this, "AspNetUserRoles");
        builder.Entity<IdentityUserClaim<string>>().ToCouchbaseCollection(this, "AspNetUserClaims");
        builder.Entity<IdentityUserLogin<string>>().ToCouchbaseCollection(this, "AspNetUserLogins");
        builder.Entity<IdentityUserToken<string>>().ToCouchbaseCollection(this, "AspNetUserTokens");
        builder.Entity<IdentityRoleClaim<string>>().ToCouchbaseCollection(this, "AspNetRoleClaims");
    }
}

public class ApplicationUser : IdentityUser { }

MVC auth example

Here’s an ASP.NET Core MVC controller with registration, login, and logout, as well as a custom role:

public class AuthController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly RoleManager<IdentityRole> _roleManager;

    public AuthController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, RoleManager<IdentityRole> roleManager)
    {
        _userManager = userManager;
        _signInManager = signInManager;
        _roleManager = roleManager;
    }

    public IActionResult Register() => View();

    [HttpPost]
    public async Task<IActionResult> Register(RegisterModel model)
    {
        if (!ModelState.IsValid) return View(model);

        var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            var roleName = "CustomRole";
            if (!await _roleManager.RoleExistsAsync(roleName))
                await _roleManager.CreateAsync(new IdentityRole(roleName));

            await _userManager.AddToRoleAsync(user, roleName);
            await _signInManager.SignInAsync(user, isPersistent: false);
            return RedirectToAction("Index", "Home");
        }

        foreach (var error in result.Errors) ModelState.AddModelError("", error.Description);
        return View(model);
    }

    public IActionResult Login() => View();

    [HttpPost]
    public async Task<IActionResult> Login(LoginModel model)
    {
        if (!ModelState.IsValid) return View(model);

        var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
        if (result.Succeeded)
            return RedirectToAction("Index", "Home");

        ModelState.AddModelError("", "Invalid login attempt.");
        return View(model);
    }

    public async Task<IActionResult> Logout()
    {
        await _signInManager.SignOutAsync();
        return RedirectToAction("Index", "Home");
    }
}

The data follows the standard Identity structure, stored in a Couchbase document. For example, a document in AspNetUser collection:

GraphQL with Hot Chocolate

Hot Chocolate is a popular GraphQL server for .NET. It can integrate with EF Core, leaning on the LINQ capabilities of the provider (which Couchbase has). This means that GraphQL queries are translated to LINQ, which is then translated to Couchbase SQL++.

Setup

public class WidgetQuery
{
    [UseFiltering]
    [UseSorting]
    public IQueryable<Widget> GetWidgets([Service] WidgetDbContext dbContext)
        => dbContext.Widgets;
}

// Program.cs:

builder.Services
    .AddGraphQLServer()
    .AddQueryType<WidgetQuery>()
    .AddFiltering()
    .AddSorting()
    .AddProjections();

app.MapGraphQL();

Example usage

Go to /graphql in browser (this brings up a web interface)

Try a query like this:

query {
  widgets(where: { name: { contains: "foo" } }, order: { createdDt: DESC }) {
    id
    name
    price
    numInStock
    createdDt
  }
}

This will return results like:

{
  "data": {
    "widgets": [
      {
        "id": "b5c494fe-135f-4f01-bf12-6e4ad1eee829",
        "name": "foobar",
        "price": 1.99,
        "numInStock": 50,
        "createdDt": "2025-06-18T18:11:19.149Z"
      }
    ]
  }
}

Tips

GraphQL queries need to match your GSI indexes (it’s just SQL++ queries under the hood).
You can use cover indexes and other SQL++ indexes to improve performance.

OData

Microsoft.AspNetCore.OData exposes your EF Core data as OData endpoints, making it easy to connect tools like Excel, Power BI, and Tableau to Couchbase.

Sample program.cs

builder.Services.AddControllersWithViews()
  .AddOData(opt =>
  {
    var odataBuilder = new ODataConventionModelBuilder();
    odataBuilder.EntitySet<Widget>("Widgets");

    opt.AddRouteComponents("odata", odataBuilder.GetEdmModel())
      .Filter()
      .OrderBy()
      .Select()
      .Expand()
      .Count()
      .SetMaxTop(100);
  });

Controller

[HttpGet("/odata/Widgets")]
[EnableQuery]
public IQueryable<Widget> GetOData() => _context.Widgets;

Example OData queries

https://localhost:7037/odata/Widgets?$filter=price gt 1&$orderby=name
https://localhost:7037/odata/Widgets?$select=name,price&$top=10

Note: Make sure your EF Core LINQ queries can be translated to SQL++ and that any filtered/sorted fields are indexed in Couchbase.

Wrapping up

All of these integrations are backed by EF Core—and now, with Couchbase support, you can take full advantage of them in your code. Whether you’re building secure web applications, GraphQL APIs or integrating with BI tools, The EF Core and Couchbase combo makes it possible.

Curious to see more? Let us know what integrations you’d like to explore next!

The post 3 EF Core Integrations That Work with Couchbase appeared first on The Couchbase Blog.

Couchbase Weekly Updates - July 11, 2025

Brian King — Fri, 11 Jul 2025 17:06:58 +0000

This week, we’re putting the “smart” in smart tech—from brainstorming AI agents and blockchain deep dives to serverless archiving and next-gen app builds, Couchbase is doing everything but making the coffee (for now). ☕️

🎙️ How I Built an Agentic RAG Application to Brainstorm Conference Talk Ideas - Our DevRel Shivay Lamba built an AI-powered agentic application that helps him ideate and draft compelling talk abstracts. It uses a research agent to do deep research on a topic—finding the latest trends, developments, and active discussions—and combines that with fast vector search using Couchbase over previous talks on the same subject from past conferences. Learn more >>
📒 Couchbase Integration with Hyperledger Fabric: A Technical Deep Dive - Hyperledger Fabric’s enterprise blockchain deployments face a critical database dilemma. Couchbase Server directly addresses these challenges by providing strong consistency with distributed ACID transactions that eliminate reconciliation issues, advanced query performance through SQL++, and comprehensive enterprise support with professional services, flexible deployment options, and advanced management tools. Read on >>
🤖 Why You Only Need Couchbase When Building Your Agents - While vector search has become widely adopted, the true differentiator in agent-powered applications is the database’s overall capability to handle diverse interaction methods, scalability, and ease of use. Couchbase excels in all these areas, providing an optimal platform for powering robust, efficient, and versatile agentic experiences with LLMs. You need this >>
🪈 A Serverless Data Archiving Pipeline from Couchbase to Cloud Storage - In this blog post, I’ll walk you through building a fully serverless archival pipeline that automatically moves documents from Couchbase to Amazon S3, using Couchbase Eventing, Amazon API Gateway, SNS, and AWS Lambda. The architecture demonstrates how to leverage asynchronous decoupling to improve resilience, scalability, and performance. Build your pipeline >>

Couchbase Weekly Updates - July 4, 2025

Brian King — Fri, 04 Jul 2025 15:07:07 +0000

From live dev streams and edge-ready demos to a slick new downloads hub—here’s what’s new and noteworthy for Couchbase developers this week!

🎙️ Couchbase Dev Streams - We’re ramping up our dev streams, with the aim of bringing you valuable learning on all things Couchbase and the wider AI and developer ecosystems that we work in. This week we talked about AI agents with Nebius AI, and next up is a walk through of Couchbase and EF Core for .NET developers. Join the group >> and catch up on recordings on our YouTube channel
✈️ Couchbase Edge Server Demo: Airline Seatback Ordering System - Couchbase Edge Server is a lightweight database server with flexible data access and cloud-to-edge sync, designed specifically for resource-constrained edge environments. This Airline Seatback Ordering System demo showcases the Couchbase Edge Server reference application. Watch the video >> and get the app source code on Github
⬇️ Downloads and Deployments Galore - Our downloads page has been revamped to make it easy for you to find the right download / deployment option across our whole product range, with handy documentation links to get you started. Get Couchbase now >>

Couchbase Weekly Updates - June 27, 2025

Brian King — Fri, 27 Jun 2025 16:16:51 +0000

Step into the wonderful world of Couchbase—where partnerships power real-time magic, vector search fuels AI adventures, and our next virtual meetup brings it all together!

📈 Couchbase and K2view Partner on Synthetic Data for Building AI Applications - Couchbase and K2view partner on synthetic data for building AI applications, giving this power directly to enterprise developers and data engineers. Together we are unlocking a new level of data agility, AI readiness, and compliance for modern enterprises. Read more >>
🎼 Introducing Couchbase as a Vector Store in Agno - We’re excited to announce that Couchbase is now supported as a vector store in Agno, an open-source full-stack framework for building multi-agent systems. This integration brings together the best of Agno’s agent orchestration capabilities and Couchbase’s high-performance, scalable vector store.. Read more >>
🛫 Building a Simple Travel Agent Workflow with n8n and Couchbase Vector Search - In this tutorial, we demonstrate how to harness the power of vector search capabilities in Couchbase with n8n’s workflow automation platform. We build a simple travel agent workflow that recommends vacation destinations based on user queries, using vector embeddings to provide contextually relevant results. Jump in >>
🦾 Dev Stream: Building Production-Ready AI Agents With Couchbase and Nebius AI - Join Couchbase and Nebius AI for an interactive session exploring how to design, build, and scale AI agents that are ready for production. Whether you're just getting started with AI agents or looking to enhance your current workflows, this event will walk you through the core concepts, critical components, and real-world best practices needed for success. RSVP >>