Forem: Couchbase

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 >>

How I Built an Agentic RAG Application to Brainstorm Conference Talk Ideas

Shivay Lamba — Tue, 08 Jul 2025 23:16:09 +0000

TL;DR

I love speaking at technical conferences. But in order to get selected to speak at the event, you need to submit a strong talk proposal or abstract—one that clearly shows relevance, technical depth, and actionable takeaways for the audience attending your talk. A good abstract isn’t just about the idea itself; it needs to show why the topic matters right now and how the talk will benefit attendees. At the same time, you want to avoid repeating something that’s already been presented.

To solve this, I built an AI-powered agentic application that helps me 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. In this case, the system is specifically designed for KubeCon, and in this post, I’ll walk you through how I built the full pipeline to create a conference talk brainstorming AI tool.

You can find the code for this project here.

Important Note 🚨

The goal of the agent is just to provide a well structured abstract idea. One shouldn't just directly copy this AI generated abstract and submit it. But use it as a source of reference and draft an original handcrafted proposal.

Tech Stack

I used a mix of tools to build this project, each handling a different part of the process. Google ADK helps run the AI agents, Couchbase stores past Kubecon talks data and performs the vector search, and Nebius Embedding model for generating embeddings and LLM models (Example: Qwen) generates summaries and talk abstracts.

Complete Pipeline Flow / Architecture Deep Dive

The system is built as a modular, multi-stage pipeline that combines historical data with real-time research to generate high-quality talk proposal ideas.

Step 1: URL Extraction / Data Collection (`extract_events.py`)

Purpose: Scrape and extract all available KubeCon talk URLs from official conference schedule pages.

# Save the KubeCon schedule HTML to a file, then run:
python extract_events.py < schedule.html

What it does:

Parses HTML content from stdin
Extracts all event URLs with pattern event/
Merges with existing URLs in event_urls.txt
Outputs the count of new URLs discovered

Output: event_urls.txt - Contains all unique talk URLs

Step 2: Talk Data Crawling / Data Ingestion (`couchbase_utils.py`)

Purpose: Crawl each talk page, extract structured metadata (title, description, speakers, tags, etc.), and store it in Couchbase using well-defined document schemas.

python couchbase_utils.py

What it does:

Reads URLs from event_urls.txt
Uses AsyncWebCrawler to fetch talk pages in batches
Extracts structured data:
- Title
- Description
- Speaker(s)
- Category
- Date
- Location
Stores directly to Couchbase with document keys like talk_<event_id>

Features:

Batch processing (5 URLs at a time)
Error handling and retry logic
Progress tracking with success/failure counts
Automatic document key generation

Step 3: Embedding Generation (`embeddinggeneration.py`)

Purpose: Generate semantic vector embeddings from talk content (title + description + category) using the intfloat/e5-mistral-7b-instruct model from Nebius AI Studio, and store them back in Couchbase for fast vector search.

python embeddinggeneration.py

What it does:

Queries all documents from Couchbase
Combines title, description, and category into searchable text
Generates embeddings using intfloat/e5-mistral-7b-instruct model
Updates documents with embedding vectors
Enables vector search functionality

Model: Uses Nebius AI's embedding endpoint for high-quality vectors

Step 4: Agent + RAG Application (`talk_suggestions_app.py`)

Purpose: The user inputs a rough topic idea via the Streamlit interface. The system runs both the research agent and vector search in parallel, then combines the outputs using a Nebius AI LLM to generate a unique, well-structured abstract with key takeaways.

streamlit run kubecon-talk-agent/talk_suggestions_app.py

Core Features:

On one side, the application performs a vector search through a database (Couchbase) of past KubeCon talks to understand what’s already been covered. On the other, it leverages a web research agent powered by Google ADK to gather the latest trends, technical developments, and community discussions around the topic. This leads into a three-stage generation process: the Research Phase, where the agent collects up-to-date context; the Retrieval Phase, where similar historical talks are surfaced; and the Synthesis Phase, where an LLM merges both streams into a compelling proposal.

Let's look a bit deeper into the 3 step process:

Research Agent Execution

I created a custom multi-agent research system using Google ADK (Agent Development Kit). This system is designed to autonomously explore the to research emerging trends across the CNCF ecosystem in real-time from trusted sources.

Here's how it works under the hood:

Parallel Execution for Web Research

The first step involves spinning up multiple research agents that gather insights independently from different web sources. I use a ParallelAgent to run all of these at the same time:

ExaAgent: Leverages the Exa API to search for recent high-quality blogs, articles, and summaries published in the past 90 days.

TavilyAgent (optional): Pulls developer sentiment and discussion threads from platforms like Reddit, X (formerly Twitter), and Dev.to.

LinkupAgent (optional): Surfaces curated technical posts, deep-dives from sites like GitHub and Hacker News.

Each of these tools is wrapped in its own LlmAgent, configured with dynamic instructions based on the user’s topic. Because they operate independently, they don’t interfere with one another and collectively reduce total response time.

These agents are executed in parallel using a ParallelAgent, ensuring low latency and independent execution. Once all the raw data is collected, it is passed to a SummaryAgent, which synthesizes the results into a clean, structured summary using a powerful LLM (nebius/Qwen/Qwen3-235B-A22B).

Sequential Reasoning for Synthesis and Insight

Once all agents (ParallelAgent) complete their respective searches, I combine their outputs into a single structured flow.

Other than search agents, the entire pipeline with steps like summarization and analysis is being done sequentially, managed using ADK’s SequentialAgent:

SummaryAgent: This agent synthesizes the raw research results into a cohesive, structured Markdown summary. It filters the highlights common themes, and stitches together the key insights from the research agents.

AnalysisAgent: This agent reviews the summary and delivers deeper insights including:

Key Trends – Major developments or patterns observed
Novel Angles – Unique viewpoints or underexplored ideas
Unanswered Questions – What the community is still trying to figure out
Contrarian Viewpoints – Active debates or non-mainstream takes

This sequential setup is intentional: the AnalysisAgent depends on the clean output from the SummaryAgent. Running them in parallel would reduce quality and coherence.

The Orchestration Layer

The full pipeline is managed through ADK’s orchestration features:

ParallelAgent → for running web search agents
SequentialAgent → for dependent reasoning steps
Runner → to execute the pipeline
InMemorySessionService → for fast, stateless execution

Here's a simplified breakdown of the pipeline:

def run_adk_research(topic: str) -> str:
    # 1. Setup Models
    nebius_base_model = LiteLlm(model="nebius/Qwen/Qwen3-235B-A22B", api_key=os.getenv("NEBIUS_API_KEY"))

    # 2. Define Agents
    exa_agent = LlmAgent(
        name="ExaAgent",
        model=nebius_base_model,
        instruction=f"Use the exa_search_ai tool to fetch the latest news and developments about '{topic}'.",
        tools=[exa_search_ai],
        output_key="exa_results"
    )

    # 3. Summarize Results
    summary_agent = LlmAgent(
        name="SummaryAgent",
        model=nebius_base_model,
        instruction="""
            You are a meticulous research summarizer. Combine the results from 'exa_results' 
            into a cohesive markdown summary. Focus on trends, notable discussions, and 
            community sentiment.
        """,
        output_key="final_summary"
    )

    # 4. Execute Pipeline
    pipeline = SequentialAgent(
        name="AIPipelineAgent",
        sub_agents=[
            ParallelAgent(name="ParallelSearch", sub_agents=[exa_agent]),
            summary_agent
        ]
    )

    runner = Runner(agent=pipeline, app_name="adk_research_app", session_service=InMemorySessionService())

    content = types.Content(role="user", parts=[types.Part(text=f"Start analysis for {topic}")])
    events = runner.run(user_id="streamlit_user", session_id="session_xyz", new_message=content)

    for event in events:
        if event.is_final_response():
            return event.content.parts[0].text

    return "Failed to generate summary."

Retrieval Agent Execution

Once real-time research is complete, the system now proceeds to retrieving historical context from past KubeCon talks. This is done using Couchbase vector search, which allows us to compare the semantic similarity of the user's idea with previous talk proposals.

What happens here?

We take the user’s query and generate an embedding using intfloat/e5-mistral-7b-instruct via Nebius' embedding API.

We then perform a vector search against a kubecontalks index in Couchbase that stores embeddings of historical talks.

Finally, we fetch the metadata (title, speaker, category, description) for the top matching talks.

This helps us:

Understand what’s already been covered.
Avoid duplicate proposals.
Borrow inspiration from successful submissions

Here's the sample code for the same:

class CouchbaseConnection:
    def __init__(self):
        connection_string = os.getenv('CB_CONNECTION_STRING')
        username = os.getenv('CB_USERNAME')
        password = os.getenv('CB_PASSWORD')
        bucket_name = os.getenv('CB_BUCKET')
        collection_name = os.getenv('CB_COLLECTION')

        auth = PasswordAuthenticator(username, password)
        options = ClusterOptions(auth)
        self.cluster = Cluster(connection_string, options)
        self.bucket = self.cluster.bucket(bucket_name)
        self.scope = self.bucket.scope("_default")
        self.collection = self.bucket.collection(collection_name)
        self.search_index_name = os.getenv('CB_SEARCH_INDEX', "kubecontalks")

    def generate_embedding(self, text: str) -> List[float]:
        client = OpenAI(base_url=os.getenv("NEBIUS_API_BASE"), api_key=os.getenv("NEBIUS_API_KEY"))
        response = client.embeddings.create(
            model="intfloat/e5-mistral-7b-instruct",
            input=text,
            timeout=30
        )
        return response.data[0].embedding

    def get_similar_talks(self, query: str, num_results: int = 5) -> List[Dict[str, Any]]:
        embedding = self.generate_embedding(query)
        search_req = SearchRequest.create(MatchNoneQuery()).with_vector_search(
            VectorSearch.from_vector_query(
                VectorQuery("embedding", embedding, num_candidates=num_results)
            )
        )
        result = self.scope.search(self.search_index_name, search_req)
        rows = list(result.rows())

        similar_talks = []
        for row in rows:
            doc = self.collection.get(row.id)
            if doc and doc.value:
                talk = doc.value
                similar_talks.append({
                    "title": talk.get("title", "N/A"),
                    "description": talk.get("description", "N/A"),
                    "category": talk.get("category", "N/A"),
                    "speaker": talk.get("speaker", "N/A"),
                    "score": row.score
                })
        return similar_talks

The results of this phase are then passed into the final synthesis stage.

Synthesis Phase

The final phase brings everything together: the user’s idea, the ADK-generated real-time insights, and the similar historical talks.

The goal is to produce a talk propsal idea proposal that is:

Timely – aligned with current trends.
Unique – not duplicating past talks.
Actionable – with clear learning objectives and audience fit.

How it works?

We use a LLM (Qwen/Qwen3-235B-A22B) to analyze:

User’s raw idea
Web analysis from the research agent
Historical KubeCon talks from vector search

We then ask the model to synthesize all of this into a structured format containing:

Title
Abstract
Key Learning Objectives
Target Audience
Why this talk is unique

def generate_talk_suggestion(query: str, similar_talks: List[Dict[str, Any]], adk_research: str) -> str:
    historical_context = "\n\n".join([
        f"Title: {talk['title']}\nDescription: {talk['description']}\nCategory: {talk['category']}"
        for talk in similar_talks
    ]) if similar_talks else "No similar talks found."

    prompt = f"""
You are an expert in cloud-native conference planning.

User's Idea:
{query}

PART 1: Historical Talks
{historical_context}

PART 2: Web Research
{adk_research}

Your task is to generate a fresh and compelling talk proposal. Follow this structure:

**Title:**  
*A catchy title that grabs attention.*

**Abstract:**  
*2–3 paragraphs outlining the core idea, approach, and takeaways.*

**Key Learning Objectives:**  
- Bullet 1  
- Bullet 2  
- Bullet 3  

**Target Audience:**  
*Beginner SREs? Advanced Platform Engineers?*

**Why This Talk is Unique:**  
*Explain how it differs from existing talks and addresses a fresh trend or gap.*
"""

    client = OpenAI(api_key=os.getenv("NEBIUS_API_KEY"), base_url=os.getenv("NEBIUS_API_BASE"))
    response = client.chat.completions.create(
        model="Qwen/Qwen3-235B-A22B",
        messages=[
            {"role": "system", "content": "You are a cloud-native conference program advisor."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=2048
    )
    return response.choices[0].message.content

This is where the magic happens. The model takes a dual-context approach—both fresh insights and past data—to recommend a proposal that’s:

grounded in reality,
informed by what’s already been done
provides real world use-cases

Final thoughts

Building this made me realize that talk ideation is just another AI use case. Blending historical talk data with up-to-the-minute research minimizes time and effort spent to getting latest information and having to spend time finding previous talks on the topics.

AI Agents help simplify tasks and can orchestrate complex workflows with ease.

Curious to try this for your own conference? Drop me a note—I’d love to hear your ideas and evolve this further with the community!

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 >>

Forem: Couchbase

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

Couchbase Weekly Updates - October 17, 2025

Couchbase Weekly Updates - October 3, 2025

Couchbase Weekly Updates - September 19, 2025

Couchbase Weekly Updates - September 5, 2025

Couchbase Weekly Updates - August 15, 2025

Couchbase Weekly Updates - August 8, 2025

Announcing Couchbase Support in Google’s MCP Toolbox for Databases

Why Couchbase + MCP Toolbox matters for developers

How it works

Agentic use cases for Couchbase + MCP

LangChain + Couchbase via MCP: integration example

Built for production

Get started

In summary

3 EF Core Integrations That Work with Couchbase

ASP.NET Core Identity

Example EF setup

MVC auth example

GraphQL with Hot Chocolate

Setup

Example usage

Tips

OData

Sample program.cs

Controller

Example OData queries

Wrapping up

Couchbase Weekly Updates - July 11, 2025

How I Built an Agentic RAG Application to Brainstorm Conference Talk Ideas

TL;DR

Important Note 🚨

Tech Stack

Complete Pipeline Flow / Architecture Deep Dive

Step 1: URL Extraction / Data Collection (extract_events.py)

Step 2: Talk Data Crawling / Data Ingestion (couchbase_utils.py)

Step 3: Embedding Generation (embeddinggeneration.py)

Step 4: Agent + RAG Application (talk_suggestions_app.py)

Research Agent Execution

Parallel Execution for Web Research

Sequential Reasoning for Synthesis and Insight

The Orchestration Layer

Retrieval Agent Execution

What happens here?

Synthesis Phase

How it works?

Final thoughts

Couchbase Weekly Updates - July 4, 2025

Step 1: URL Extraction / Data Collection (`extract_events.py`)

Step 2: Talk Data Crawling / Data Ingestion (`couchbase_utils.py`)

Step 3: Embedding Generation (`embeddinggeneration.py`)

Step 4: Agent + RAG Application (`talk_suggestions_app.py`)