Personal Access Tokens for your AI Agents - an autonomous research flow with Sombra

How to connect Sombra to LangGraph, CrewAI, OpenAI Agents SDK, and other agentic frameworks using personal access tokens.

Sombra Team·March 11, 2026

The agentic framework landscape right now is something else. LangGraph, CrewAI, OpenAI Agents SDK, Pydantic AI, Google ADK, Microsoft's AutoGen/Semantic Kernel/Agent Framework (yes, we're all confused too).

There are a lot of them, and new ones keep appearing. You may even be rolling your own. How hard can it be, right?

LangGraph's graph-based control flow is elegant if you need deterministic routing. CrewAI's role-based model maps well to how you'd actually divide work. The OpenAI SDK gets you from zero to working agent absurdly fast if you don't mind being locked to their models. Hand rolling is fun if you enjoy really getting into the weeds. Been there, was fun, probably wouldn't do it again. Ask me about the homebrew MTV station sometime... or maybe not.

In all of them though, your agent is only as good as what it knows, and what it knows is its training data plus whatever you can provide as context. If you spent yesterday compiling migration docs and comparing approaches across three blog posts, your agent knows none of that. It's working off whatever was in the training set eighteen months ago, whatever might pop up in searches (which may change), and you can't really guarantee that it will always be the specific thing you require, loop after loop.

If what you need isn't on the public web, then even worse.

So - you paste docs into prompts and md files in repo after repo, UI after UI. You re-explain what you already know. The agent hallucinates an API endpoint or biography because it never saw the page you saw, or the blog that had that One Piece Of Information was offline when the loop ran.

This is what Sombra is for, and this post is about how it can connect to the frameworks you use, using a headless, no human in the loop PAT (Personal Access Token).

What Sombra does, quickly

If you haven't come across it before: Sombra is a suite of tools that includes an MCP server that gives your AI tools a persistent knowledge base and web research library. You save notes and web pages (the web app, Chrome extension or conversationally via MCP), organise them into collections scoped to projects or tasks, and distil the important parts down to dense context notes. Any MCP client reads the same library. Claude Desktop, Claude Code, Cursor, ChatGPT, whatever speaks MCP.

The distillation part is baked into specific context engineering tools with specialised prompts to focus the Assistant on what is relevant. Forty pages of raw framework docs in your agent's context is noise. Five hundred tokens that capture the breaking changes, the key API differences, and the three config flags that will actually bite you? That's signal - and that is how makes agents produce astonishing, repeatable output.

The connection is the same regardless of framework:

URL: https://sombra.so/mcp
Transport: Streamable HTTP
Auth: OAuth 2.1 (interactive) or Bearer token (headless agents)

OAuth for when a human is in the loop (Claude Desktop, VS Code, Web app, Chrome Extension). Personal access tokens for headless pipelines where nobody's around to click "Authorize." You generate tokens in the Sombra dashboard, save to your secure environment, done.

Model Context Protocol Just Works

LangGraph has an adapter that auto-discovers MCP tools. CrewAI lets you reference MCP servers directly in agent config. OpenAI baked MCP support into the Agents SDK and ChatGPT. Pydantic AI maps MCP tools to typed function signatures. Google ADK integrates through LangChain bridges. Microsoft's frameworks have MCP support in both .NET and Python.

Sombra is published to Anthropic's MCP Registry, so any client that discovers servers through the registry finds it automatically.

LangGraph

LangGraph is the one I'd reach for if I needed fine-grained control over when context loads and when it updates. Its graph-based approach means you can be explicit: this node reads the distilled context from Sombra, this node generates code against it, this node saves discoveries back. Map those nodes to specific flows or tools, and you can wake up to clean, organised web research.

from langchain_mcp_adapters.client import MultiServerMCPClient

async with MultiServerMCPClient({
    "sombra": {
        "url": "https://sombra.so/mcp",
        "transport": "streamable_http",
        "headers": {
            "Authorization": "Bearer sombra_pat_..."
        }
    }
}) as client:
    tools = client.get_tools()
    # browse_collections, read_collection_context, save_url, etc.

The interesting pattern: build a technical or research collection in Sombra, distil it, then wire a LangGraph node that reads the distillation before the code generation or report nodes run. The agent writes against accurate, current docs. Not training data from 2024, or 404s from flaky web services.

CrewAI

This is where Sombra's model clicks most naturally, and their conceptual framework maps nicely to how the MCP tools are structured.

CrewAI thinks in roles. Researcher, Analyst, Writer. Each with specific tools. Give the Researcher access to Sombra's save and organise tools. Give the Analyst the read and search tools. The Researcher builds the collection; the Analyst reads and writes the distilled context and does the actual work.

agents:
  researcher:
    role: "Research Specialist"
    tools:
      - mcp:
          url: "https://sombra.so/mcp"
          headers:
            Authorization: "Bearer sombra_pat_..."
    goal: "Build a comprehensive collection on {topic}"

  analyst:
    role: "Technical Analyst"
    tools:
      - mcp:
          url: "https://sombra.so/mcp"
          headers:
            Authorization: "Bearer sombra_pat_..."
    goal: "Analyse the collection and produce recommendations"

Research and full history persists between runs. Monday's research session feeds Wednesday's analysis. The crew builds institutional knowledge over time instead of starting from scratch every execution. This is the bit most agent setups get wrong. They treat every run as stateless. Your research should compound, not evaporate.

OpenAI Agents SDK

Most minimal of the lot. Define agents with instructions and tools, wire up handoffs, the SDK manages the loop. Good for getting something working fast, less good if you need complex conditional routing (that's LangGraph territory), or you want more portability.

The handoff pattern works nicely with Sombra: triage agent decides the query needs research, hands off to a specialist that reads from Sombra, specialist hands back with context loaded.

If you're inside OpenAI's stack, Sombra means your agents access the same knowledge base your Claude and Cursor workflows use. The context isn't trapped in one provider's conversation history. Did we mention you can plug in Google Drive and Dropbox sync natively too?

The others, briefly

Pydantic AI is gaining traction fast. Built by the team behind Pydantic itself, which quietly powers the internals of many other AI frameworks. Clean type-safe tool system. MCP tools from Sombra map into it naturally.

Google ADK and Microsoft Agent Framework both support MCP. Google's integrates through LangChain/CrewAI bridges. Microsoft's reached RC earlier this year. If you're in any ecosystem: same URL, same transport, same tools. It just works.

The workflow that matters more than the framework

Honestly, which framework you pick matters less than whether you're doing this:

Save the specific signal. Official docs, the architecture guide, the one blog post that actually explains the edge case you're hitting. Not everything. The authoritative sources, fixed and portable.
Scope your collections. One per project or task. "EU e-invoicing integration." "React -> Svelte migration patterns." "Competitor analysis Q2." Scoped beats sprawling, every time.
Distil. Write (or, better, have your agent write via specialised automatic prompts) a collection context that captures the token-friendly signal. Code examples and CLI commands verbatim. Everything else compressed to dense prose. One distillation replaces forty pages of raw docs in your agent's context.
Connect. Point your framework at https://sombra.so/mcp. Agent reads the distillation. Writes code against current docs instead of stale training data.
Let it accumulate. The agent saves what it learns back to the collection. Next run, the context is richer. Research compounds. Conversations end; knowledge doesn't have to.

Getting started

Interactive (Claude Desktop, VS Code, Cursor):

claude mcp add --transport http sombra https://sombra.so/mcp

OAuth handles auth through a browser flow. That's it.

Headless agents (LangGraph, CrewAI, pipelines):

Sign up at sombra.so
Generate a personal access token in Settings > Access Tokens
Pass it as a Bearer header in your MCP config - instructions are given in the app.

Sombra's in the Anthropic MCP Registry too, so clients that auto-discover servers will find it.

If you've been solving the "feed my research into AI tools" problem a different way, we'd love to hear what's working for you. And if you try Sombra with one of these frameworks and hit friction, that's useful too.

Sombra is a research library for AI agents. Save web pages, organise into collections, distil what matters, serve it through MCP. Start free.