Langbase

@Langbase list all my pipes and show me which ones are using the GPT-4 model

Found 7 pipes in your Langbase account. Three are using GPT-4: 'customer-support-bot' (last deployed 2 days ago), 'code-review-assistant' (active, 1.2k runs this month), and 'sales-email-drafter' (paused). The remaining four pipes use Claude 3.5 Sonnet. Each pipe's API key and endpoint URL are available in the full details if you need to integrate them into your application.

This example demonstrates read-only access to your Langbase pipe inventory. Requires an API key with read permissions. Useful for auditing which LLM models your team is deploying across different workflows. The MCP returns metadata only — it won't execute or modify pipes.

@Langbase create a new memory called 'product-docs' and upload our latest API reference markdown file

Created memory 'product-docs' successfully. The memory is now ready to store documents. However, the MCP's current tool set creates the memory container but does not handle file uploads directly — you'll need to use Langbase's document ingestion API or UI to add the markdown file. Once uploaded, this memory can be attached to pipes for retrieval-augmented generation in customer support or internal Q&A workflows.

This example shows memory creation, a write operation that sets up a knowledge base. The MCP creates the memory object but stops short of uploading documents — that requires additional API calls outside this tool's scope. Be aware that memory storage counts against your Langbase plan limits.

@Langbase start a new thread for our 'customer-support-bot' pipe and ask it to summarize the top 3 unresolved issues from the product-docs memory

Created thread `thrd_9x4k2m` and sent your query to the 'customer-support-bot' pipe. The bot retrieved context from 'product-docs' memory and identified: (1) API rate limit confusion (mentioned in 8 documents), (2) webhook signature verification errors (6 documents), and (3) OAuth redirect URI mismatch (4 documents). The thread is now active — you can continue the conversation by referencing this thread ID in follow-up prompts.

This example combines thread creation with a reasoning task that leverages stored memory. It showcases how Langbase pipes can synthesize information from your knowledge base. The MCP initiates the thread but doesn't stream the pipe's full response — you'll see a summary. Thread IDs persist across sessions for multi-turn conversations.

When Langbase beats a static doc site for support teams

A 6-person support team fields 40 tickets a day across Slack and email. They store product docs, past ticket resolutions, and internal runbooks in Langbase memories, then query them via pipes during live conversations. The memory-list and document-list tools let agents confirm what's indexed before pulling an answer. This works when your knowledge base changes weekly and you need versioned retrieval without rebuilding a search index. If your docs are stable and you already have a good search tool, Langbase adds overhead. But if you're stitching together Notion pages, Slack threads, and Google Docs into one queryable layer, the memory abstraction saves you from writing custom embeddings logic. Worth the API key if you're hiring support person number 4 and can't afford a dedicated knowledge engineer.

How thread management scales agency client handoffs

A 10-person creative agency runs discovery calls with 8 active clients. Each client conversation spawns a Langbase thread that persists context across weeks of back-and-forth. The create-thread and get-thread-details tools let account managers pick up where the last person left off without re-reading Slack history. This shines when your team juggles 5+ concurrent client projects and needs isolated conversation state per client. If you're a solo consultant or a team that works one client at a time, threads are overkill—just use a shared doc. The trade-off: Langbase charges per API call, so high-frequency chat (50+ messages per thread per day) gets expensive fast. Best fit is low-frequency, high-context work where forgetting a client detail costs more than the API bill.

When pipes let product teams test prompts without code

A 4-person product team wants to test a new AI feature idea—summarizing user feedback from Intercom—before writing production code. They use Langbase's create-pipe tool to spin up a prompt chain in 10 minutes, wire it to a memory holding sample feedback, and share the pipe URL with stakeholders. The list-pipes tool helps them track which experiments are live. This is the right call when you need to validate a feature hypothesis in days, not sprints, and your eng team is underwater. If you're already running inference in-house or your feature needs sub-200ms latency, Langbase's API layer adds latency you can't afford. The buying threshold: if stakeholder buy-in is the blocker and you can tolerate 1-2 second response times, pipes get you to a demo faster than a Jupyter notebook.