Agentic-RAG primitive

Don't build RAG. Plug into Leapable.

Your agent already supports MCP. Leapable gives it verifiable, multi-format retrieval through 191 MCP tools, 10 MCP client configurations, and a SHA-256 provenance chain.

Install Free View developer quickstart

Built for AI agent developers who want source-cited private context without assembling storage, OCR, rerank, audit, and provenance systems from scratch.

Works with:
  • Claude
  • Cursor
  • ChatGPT
  • VS Code
  • Windsurf
  • Zed
  • Continue
  • JetBrains
  • Amazon Q
Leapable developer workspace showing an AI agent answer beside cited source context
191 MCP tools Retrieval, extraction, verification, workflow, and governance tools.
10 MCP client configurations Claude, Cursor, ChatGPT, VS Code, Windsurf, Zed, Continue, and more.
21 file types Code, specs, runbooks, PDFs, Office files, images, CSV, Markdown, and text.
768-d HNSW Hybrid retrieval with lexical search and Cross-encoder rerank.
SHA-256 provenance chain Every cited answer keeps source bytes and transformations checkable.

MCP-native pitch

Your agent already supports MCP.

Leapable is the MCP server that gives an agent private, multi-format context with citations. Keep your current orchestrator and model; swap the brittle RAG assembly work for a local-first workspace with provenance.

  • Claude
  • Cursor
  • ChatGPT
  • VS Code
  • Windsurf
  • Zed
  • Continue
  • JetBrains
  • Amazon Q
Flowchart: code and docs to Leapable developer workspace to AI client to cited agent patch context

Context patterns

Three patterns for agentic RAG.

Router

Let the agent choose the right Leapable tool or workspace for the task instead of forcing every prompt through one retrieval path.

ReAct

Alternate reasoning, source lookup, page inspection, and final answer generation while keeping citations attached to each step.

Multi-source

Combine code, product docs, runbooks, tickets, exported chats, and private PDFs in one MCP-accessible context surface.

Attribution: Boris Cherny's Claude Code discussion frames production agent search as tool-driven and context-aware. Anthropic context engineering treats tools, MCP, external data, and message history as context state an agent must curate. See Latent Space with Boris Cherny, Anthropic context engineering, and Anthropic Model Context Protocol.

Use cases

Ten developer use cases.

Code RAG

Ask across repos, docs, and runbooks with file-level citations.

Company brain

Give internal agents cited answers from team docs and decisions.

Sales

Surface approved decks, win notes, and product facts during calls.

Support

Ground replies in KB articles, release notes, and resolved tickets.

RFP

Reuse approved answers with citations to the policy or prior response.

Security questionnaires

Answer evidence requests from SOC, DPA, controls, and runbook sources.

Legal

Keep matter-specific context scoped and cited for counsel review.

Research

Work over papers, lab notes, and private references with source links.

Healthcare

Keep clinical and operations context tied to source documents.

Investigation

Trace people, dates, entities, and source pages across evidence drops.

Capabilities

191 tools grouped for agent workflows.

The tool surface is intentionally broad because agents need more than a nearest-vector answer. Leapable exposes retrieval, source inspection, extraction, comparison, clustering, provenance, compliance, events, prompts, lab workflows, and repair tools through one MCP surface.

Retrieval

Hybrid search, cross-workspace search, saved searches.

Inspection

Source page, document metadata, page context.

Extraction

Fields, tables, clauses, reports, comparisons.

Governance

Audit log, provenance graph, chain hash, budgets.

Architecture

Architecture that keeps context verifiable.

Layer DIY RAG stack Vector framework Enterprise AI platform Leapable
Agent interface You design tool contracts and adapters Framework-specific SDK Vendor console and connectors MCP-native with 10 client configurations
Retrieval path Custom lexical + vector + rerank plumbing Bring storage, OCR, rerank, and provenance Managed cloud retrieval 768-d HNSW, lexical search, and cross-encoder rerank
Source formats Whatever you write and maintain Loader quality varies by integration Connector-limited 20 file pipeline with OCR and source-page access
Verification You build traceability after the prototype Usually application-owned Vendor-specific audit surface Audit log, provenance graph, SHA-256 chain

Quickstart

Five-line MCP quickstart.

Install Leapable, connect your MCP-capable client, add a developer workspace, and call the same tool names from your agent loop. 

leapable_status
leapable_db_create name="agent-docs" tags=["developer","mcp"]
leapable_ingest_files database_name="agent-docs" paths=["./docs","./runbooks","./src"]
leapable_search query="Which runbooks describe webhook rotation?" mode="hybrid" include_provenance=true
leapable_document_page document_id="doc_..." page=3

Advanced

Advanced integration surface.

Use the HTTP MCP endpoint for streamable clients, call getToolNames() when you need the exact tool list in-process, and bring your own LLM or orchestration layer.

API and Pro plan details View GitHub 
import { getToolNames } from 'leapable-mcp/server/register-tools';

const transport = 'leapable-mcp --transport stdio';
const tools = getToolNames();
// Pass transport + tools to the agent planner you already run.

Demo

Code, docs, runbooks, cited context.

Demo flow: add repository docs and operations runbooks, ask for patch context, open the cited source page, and hand the result back to your coding agent.

Transcript pending until the developers MCP integration walkthrough is uploaded.

Pricing

Pricing for builders, agent teams, and platform rollout.

Builder covers a solo developer or early prototype. Pro adds API/SDK and HTTP MCP access for repeat agent workflows. Elite covers larger rollouts and custom integration support.

Open source

Open source, inspectable, and local-first.

Leapable is developed in the open. The sidecar, dashboard, installer, MCP tool registry, provenance services, and tests live in the GitHub repo so teams can inspect the contracts behind the claims on this page.

Open GitHub View the 191 tools MCP Registry listing coming soon

FAQ

Built to sit behind the agent you already use.

Does Leapable replace my agent framework?

No. Leapable is the MCP-native source layer. Keep Claude, Cursor, ChatGPT, VS Code, LangGraph, custom orchestrators, or any other MCP-capable client.

How do AI clients connect to Leapable?

AI clients connect to the bundled sidecar over stdio (leapable-mcp --transport stdio). Stdio is the supported integration path for Claude Code, Claude Desktop, Cursor, and the MCP SDK.

Can I bring my own LLM?

Yes. Leapable is model-agnostic MCP infrastructure. Your agent chooses the model; Leapable supplies cited private-source context and provenance.

Is the MCP Registry listing live?

Not yet. registry.modelcontextprotocol.io/leapable returns no public listing, so the page shows MCP Registry listing coming soon until the official slug resolves.

Final CTA

Stop rebuilding retrieval plumbing.

Install Leapable, point your agent at MCP, and make private-source context checkable before you ship another agent workflow.

Install Free for Developers Book an architecture call View the 191 tools