Integration

Langbase integration

Langbase is a serverless platform for AI agents built from pipes (a prompt, model and tools configured in Langbase Studio), memories (RAG stores of documents) and threads (stored conversations). Run a pipe on messages and get its completion, create, list and update pipes, create and search memories and manage their documents, keep conversation threads, split text into chunks, embed text and extract text from PDF, CSV, Excel or text files. Uploading a document into a memory (a signed-URL upload), the Agent Run and Images APIs and the web search and crawl tools are not exposed, since each needs a provider key or a second request this integration cannot send. Authentication is a Langbase user or organization API key (Studio, API keys) sent as a Bearer token; LLM calls use the provider keys saved in your Langbase keysets.

Connect Langbase How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in Langbase.Built from the 20 Langbase tools below, on the connection you add once.

What you can do with Langbase

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Pipe, 4 operations

create_pipeCreate pipePOSTCreates a pipe (an AI agent: prompt, model, tools and memories) and returns its name, owner, status and Studio URL. With upsert=true an existing pipe of the same name is updated instead.
list_pipesList pipesGETLists the pipes of the account with name, description, visibility status, model and their configured settings (stream, json, store, sampling, prompt messages, variables, tools, memory).
run_pipeRun pipePOSTRuns a pipe on messages (an LLM call, billed and counted as Langbase runs) and returns its completion and raw response. For a conversation, call create_thread first and pass its id as threadId: this tool cannot return a new thread's id.
update_pipeUpdate pipePOSTUpdates a pipe's settings (model, prompt messages, tools, memories, sampling, visibility). Settings you leave out keep their current value.

Thread, 4 operations

create_threadCreate threadPOSTCreates a conversation thread, optionally with your own id, metadata and initial messages. Returns its id, to pass as threadId to run_pipe and the thread tools. Counts as runs.
delete_threadDelete threadDELETEDeletes a thread. Returns success.
get_threadGet threadGETReturns a thread: id, creation time and metadata. Use list_thread_messages for its messages.
update_threadUpdate threadPOSTUpdates a thread's metadata: the key-value pairs you send are added or replace the existing keys. Returns the thread.

Memory, 3 operations

create_memoryCreate memoryPOSTCreates a memory (a RAG store) to hold documents and be searched by pipes or retrieve_memory_chunks. Returns its name, owner, embedding model and Studio URL.
delete_memoryDelete memoryDELETEDeletes a memory. Returns success.
list_memoriesList memoriesGETLists the memories of the account with name, description, owner and Studio URL.

Memory document, 3 operations

delete_memory_documentDelete memory documentDELETEDeletes a document from a memory. Returns success.
list_memory_documentsList memory documentsGETLists the documents of a memory with their processing status (queued, in_progress, completed or failed), status message, size, type, chunk settings and whether each is enabled.
retry_document_embeddingsRetry document embeddingsGETRestarts embedding of a memory document whose processing failed (status failed in list_memory_documents). Returns success when the retry started.

Thread message, 2 operations

append_thread_messagesAppend thread messagesPOSTAppends messages to a thread and returns the stored messages with their ids. Counts as runs against your plan.
list_thread_messagesList thread messagesGETLists the messages of a thread: id, role, content, tool calls, name, attachments, metadata and creation time (Unix seconds).

Document, 1 operation

parse_documentParse documentPOSTExtracts the text of a document file (PDF, TXT, Markdown, CSV, XLSX, XLS or code files, up to 10 MB) and returns it as content.

Embedding, 1 operation

embed_textEmbed textPOSTReturns one embedding vector (a list of numbers) per input chunk, in input order, as a bare list. Up to 100 chunks of at most 8192 characters each. Counts as runs.

Memory chunk, 1 operation

retrieve_memory_chunksRetrieve memory chunksPOSTSearches memories for the chunks most similar to a query: each has text, similarity (0 to 1) and meta (document name and metadata), returned under chunks or as a bare list of such items.

Text, 1 operation

chunk_textChunk textPOSTSplits text into chunks of up to chunkMaxLength characters with chunkOverlap characters of overlap, for embedding or storage. Counts as runs against your plan.

Use Langbase from Claude Code, Cursor or Codex

Connect Langbase in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its Langbase operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect Langbase

Create your workspace
Sign up free. Nothing to install.
Connect Langbase once
Add your Langbase connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.