Provides a semantic cache layer for AI agents that extracts atomic facts and automatically invalidates them when underlying sources change.
Also known as Vectorlink-Labs/coalent
- Stars
- 13
- Tools
- —
- Downloads, 30 days
- 349
- Latest version
- 0.7.0
- Last commit
- Sep 17, 2026
- License
- Apache-2.0
What is Coalent MCP?
Coalent provides a semantic cache layer for AI agents that extracts atomic facts and automatically invalidates them when underlying sources change.
Summary generated from the project's README
About Coalent MCP server
Coalent provides a semantic cache layer designed for AI agents and retrieval-augmented generation workflows. Instead of caching raw text chunks, it extracts atomic, source-grounded claims to build a query-independent understanding of your data. This allows a single cached unit to answer multiple different questions. The system sits above your existing retrieval stack, such as a vector database or API, acting as a freshness and reuse layer rather than a replacement for your retriever.
Developers can integrate this via the coalent-mcp server into clients like Claude Code or Cursor. It supports various deployment modes, including a zero-config folder watch mode and a factory mode where you provide your own SemanticCache configuration. The server can also run as a shared service via HTTP to allow multiple concurrent agents to use a single, compounding cache. It requires an LLM provider and an embedder, such as OpenAI, to function effectively.
What you can do with it
- 1Preventing stale AI responsesAutomatically invalidate cached facts the moment an underlying document or source is updated.
- 2Reducing LLM costsReuse extracted understanding across different queries and agents to avoid redundant model calls.
- 3Answering multi-hop questionsConnect claims across different documents to answer complex queries without extra retrieval steps.
- 4Integrating with existing toolsConnect the semantic cache to your current LangChain or MCP-compatible development environment.
Written from the project's README. Every use case is checked against a quote from it.
How to install Coalent MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Coalent MCP in Claude Code
$ claude mcp add --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'COALENT_MCP_TOKEN=<YOUR_COALENT_MCP_TOKEN>' coalent -- uvx coalentInstall Coalent MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"coalent": {
"command": "uvx",
"args": [
"coalent"
],
"env": {
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"COALENT_MCP_TOKEN": "<YOUR_COALENT_MCP_TOKEN>"
}
}
}
}Install Coalent MCP in VS Code
.vscode/mcp.json
{
"servers": {
"coalent": {
"type": "stdio",
"command": "uvx",
"args": [
"coalent"
],
"env": {
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"COALENT_MCP_TOKEN": "<YOUR_COALENT_MCP_TOKEN>"
}
}
}
}Install Coalent MCP in VS Code CLI
$ code --add-mcp '{"name":"coalent","type":"stdio","command":"uvx","args":["coalent"],"env":{"OPENAI_API_KEY":"<YOUR_OPENAI_API_KEY>","COALENT_MCP_TOKEN":"<YOUR_COALENT_MCP_TOKEN>"}}'Install Coalent MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"coalent": {
"command": "uvx",
"args": [
"coalent"
],
"env": {
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"COALENT_MCP_TOKEN": "<YOUR_COALENT_MCP_TOKEN>"
}
}
}
}Install Coalent MCP in Codex
$ codex mcp add coalent --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'COALENT_MCP_TOKEN=<YOUR_COALENT_MCP_TOKEN>' -- uvx coalentInstall Coalent MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.coalent] command = "uvx" args = ["coalent"] [mcp_servers.coalent.env] OPENAI_API_KEY = "<YOUR_OPENAI_API_KEY>" COALENT_MCP_TOKEN = "<YOUR_COALENT_MCP_TOKEN>"
Install Coalent MCP in Gemini CLI
$ gemini mcp add -s user -e 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' -e 'COALENT_MCP_TOKEN=<YOUR_COALENT_MCP_TOKEN>' coalent uvx -- coalentInstall Coalent MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"coalent": {
"command": "uvx",
"args": [
"coalent"
],
"env": {
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"COALENT_MCP_TOKEN": "<YOUR_COALENT_MCP_TOKEN>"
}
}
}
}Configuration
OPENAI_API_KEYRequiredSecretRequired in folder (--watch) mode for semantic embeddings (text-embedding-3-small) and build synthesis (gpt-4o-mini); the server exits loudly without it rather than degrade. Factory (--cache-factory) mode brings its own models and needs no key.
COALENT_MCP_TOKENSecretOptional shared secret for --transport http: when set, every HTTP request must carry Authorization: Bearer <token>. Unused over stdio.
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubYour agent re-reads the same sources on every call — and the moment a source changes, every cached answer is silently wrong.
Coalent builds the understanding once, caches it by what the query means, and invalidates it surgically the instant an underlying source changes. As correct as re-reading everything, at a fraction of the cost — and never stale.
Why Coalent
Every context layer is forced to trade off three things. Coalent is built to hold all three at once:
- 🧠 Extractive understanding, not chunks. It caches a query-independent set of atomic, source-grounded claims your LLM extracted — keeping every number and fact — so one cached unit answers many different later questions. The raw evidence is retained with each unit, so a hit that under-covers a query falls back to retrieval instead of answering thin.
- ♻️ Reuse across queries, agents — and documents. A semantic cache keyed by query meaning: ask again, or from another agent, and it's a warm hit. Cross-unit recall pools claims across units to answer multi-hop questions whose evidence spans documents — at zero extra LLM calls.
- 🌿 Fresh by provenance. Every unit remembers the exact sources it used. When one changes, only the units that actually used it go stale — precisely, automatically, and lazily.
Coalent sits above retrieval — bring any retriever (vector DB, hybrid search, GraphRAG, tools, APIs). It's the freshness-and-reuse layer, not another retriever — deliberately the opposite of GraphRAG's build-the-whole-graph-upfront tax: lightweight, independent units, built lazily only when a query actually needs one, and refreshed by dirtying a single unit (no graph surgery).
New in v0.7 — the self-healing release. The failure chain: when a read fails, your agent calls
repair(read_id)and the cache re-extracts what its build missed — permanently. Measured on the same frozen 605-question rig: 0.826 vs 0.774 for the strongest v0.6 configuration, +5.3 points at an identical ~983-token serving budget, final refusals −69%. And the default read path flips to pool: under a semantic embedder the read path resolves to"pool"automatically (read_path="unit"stays the byte-identical escape hatch). See What's new in v0.7.New in v0.6.1 — the MCP server:
coalent-mcpputs the cache one line away from Claude Code, Cursor, or any MCP client (Use it from Claude Code / Cursor), andlangchain-coalentmakes your existing LangChain stack the cache's substrate. Both additive-only.v0.6 — the pool read path (
read_path="pool"): every read serves the token-budgeted, globally ranked fresh-claim pool. Measured on the same benchmark: 0.731 accuracy @ 981 context tokens — naive's best measured accuracy (top-12: 0.731 @ 1,729) at ~43% fewer tokens. Plus the default-OFF behavioral stack, measured at −33% refusals and +3.1 pts on the same store.
Install
pip install coalent # the core has zero required dependencies
Quickstart
Runs as-is — StubSynthesizer needs no API key, so you can feel the loop in ten seconds:
from coalent import SemanticCache, InMemoryRetriever, StubSynthesizer
# 1. Any retriever — a vector DB, a tool, an API. (In-memory here for the demo.)
retriever = InMemoryRetriever()
retriever.add("confluence:hr", "Leave policy: 21 days of annual leave per year.")
# 2. Build the cache. Swap StubSynthesizer for a real LLM below.
cache = SemanticCache(retriever, StubSynthesizer())
# 3. Ask. The first call builds understanding and caches it; the next is a warm hit.
result = cache.get("what is our leave policy?")
print(result.context["understanding"])
print(result.cache_hit) # False (cold) -> True on the next call
# 4. A source changed? Only the units that used it go stale — surgically.
cache.source_changed("confluence:hr", text="Leave policy: now 25 days.")
# the next matching read rebuilds just that one unit, lazily
(The no-key demo above runs the classic unit read path — with no semantic embedder available, the cache says so loudly and falls back. Wire a real embedder, as below, and the default becomes the measured pool read path.)
Wire in a real model — any text-in / text-out LLM works. In v0.4 the synthesizer builds extractive understanding by default (query-independent atomic claims that keep every fact), and the cache does cross-unit recall — both on automatically:
from coalent import SemanticCache, LLMSynthesizer, OpenAIProvider, OpenAIEmbedder
cache = SemanticCache(
retriever,
LLMSynthesizer(OpenAIProvider(), model="gpt-4o-mini"), # extract=True by default (v0.4)
embedder=OpenAIEmbedder(), # match queries by MEANING (recommended for real use)
)
# ^ with a semantic embedder, v0.7 resolves the default read path to "pool" — the
# measured path. Pass read_path="unit" for the pre-0.7 unit default, byte-identical.
# Multi-hop across documents? recall is already on; raise its trigger to bridge units:
# SemanticCache(retriever, synth, embedder=..., recall_threshold=0.7)
The pool read path — the DEFAULT since v0.7 (whenever a semantic embedder is available): every read serves the budget-packed, globally ranked fresh-claim pool instead of one routed unit. Attribution is the one thing to wire: a 3-line pool_header callable mapping each unit to [title | source | date] from your own corpus metadata. This is the measured golden path — on a 605-question news benchmark (strict grading), 0.68 accuracy with the bare built-in header vs 0.73 with this callable, same store, same queries:
DOC_META = { # your corpus metadata, keyed by artifact id
"docs:azure-refresh": {"title": "Azure region refresh", "source": "CloudWire", "date": "2026-05-02"},
}
def pool_header(unit) -> str: # the [title | source | date] golden path — 3 lines
meta = DOC_META.get(unit.evidence[0].artifact_id if unit.evidence else "")
return f"[{meta['title']} | {meta['source']} | {meta['date']}]" if meta else f"[source: {unit.id}]"
cache = SemanticCache(retriever, synthesizer, embedder=OpenAIEmbedder(),
pool_header=pool_header) # pool is the resolved default (v0.7)
result = cache.get("which regions got the refresh?")
result.context["pool"] # the packed, attributed claim payload — hand it to your answer model
Runnable no-API-key demo, including the refusal loop: examples/pool_read_path.py.
Use it from Claude Code / Cursor (MCP)
coalent-mcp serves fresh, attributed facts from a Coalent cache to any MCP client —
and the facts are invalidated the instant their source changes. One line to wire it into
Claude Code:
pip install "coalent[mcp,openai]"
claude mcp add coalent -- coalent-mcp --cache-factory my_cache:build
(Cursor / Claude Desktop / any MCP client: register the same coalent-mcp ... command in
its MCP config.)
Bring your own cache (--cache-factory module:function) — the primary mode. Your
factory returns a fully constructed SemanticCache: your vector DB, your embedder, your
LLM, every knob. The server adds protocol glue only — and the glue is measured to add
zero quality loss: factory mode reproduced the library's own benchmark result
byte-identically (0.710 on a 100-question validation run drawn from our n=605 news
benchmark — identical CIs, 100/100 serves, 98/100 answer payloads byte-equal to the
library run).
# my_cache.py — importable from the directory you launch in
from coalent import (SemanticCache, LLMSynthesizer, OpenAIProvider,
OpenAIEmbedder, SQLiteCognitionStore)
def build() -> SemanticCache:
return SemanticCache(
my_vector_retriever, # YOUR vector DB / retriever
LLMSynthesizer(OpenAIProvider()), # YOUR synthesis model
embedder=OpenAIEmbedder(), # YOUR embedder
read_path="pool",
residual_spans=True, query_keys=True, # the behavioral stack, opt-in as ever
pool_header=my_metadata_header, # [title | source | date] — the measured golden path
store=SQLiteCognitionStore("kb.db"), # persistence is yours too
)
Freshness here is signal-driven: your ingestion pipeline calls the source_changed tool
when a document changes and the affected facts invalidate immediately. (Adding
--watch DIR alongside the factory also fires it on file edits — invalidation only; it
never ingests into your index, and it matches only when your artifact ids equal the
watch-relative paths.)
Zero-config folder mode (--watch DIR) — the demo wedge. Point it at a folder of
docs and you get the recommended v0.6 deployment (pool path, residual spans, query keys,
SQLite persistence, automatic [path | modified date] attribution) with no code at all:
claude mcp add coalent --env OPENAI_API_KEY=$OPENAI_API_KEY -- coalent-mcp --watch ./docs
Every read rescans the watched files (mtime + content hash) before serving — you cannot get a stale answer after saving a file — and an untouched folder restarts fully warm. The honest number: on the same 100-question validation run, folder mode scored 0.46 vs 0.71 for a factory-built cache (40 vs 18 refusals) — the measured cost of the generic paragraph chunker and on-demand keyhole builds. Use it to feel the freshness loop in a minute; bring your own stack for production quality. One regime note: a question about a just-added file can honestly refuse from a warm cache until a read triggers that file's first build — a refusal, never a stale or wrong answer.
One shared cache for many agents (--transport http).
COALENT_MCP_TOKEN=<secret> coalent-mcp --cache-factory my_cache:build --transport http --port 8765
One long-lived process, many concurrent MCP clients, ONE shared cache — shared
compounding, no store races (validated: two concurrent clients matched the sequential
reference on all 20 reads, zero duplicate builds). When COALENT_MCP_TOKEN is set, every
request must carry Authorization: Bearer <token> — bind localhost or trusted networks.
Corollary for stdio: each stdio launch is its own process, so never point two apps at the
same --store path — HTTP mode is the shared-cache answer.
The seven tools: get_context(query, budget?) → the attributed, budget-packed
payload + a read_id · report_refusal(read_id) / report_success(read_id) → the
behavioral repair loop over MCP · source_changed(artifact_id, text?) → the BYO
freshness feed (unchanged content is hash-detected and skipped) · list_sources() ·
cache_stats() · refresh().
LangChain
langchain-coalent makes Coalent a LangChain-native
freshness/reuse layer — BYO-first: your existing VectorStore (or retriever), embeddings,
and chat model become the cache's substrate, unchanged.
pip install langchain-coalent
from langchain_coalent import create_coalent_cache, CoalentRetriever
cache = create_coalent_cache(my_vectorstore, llm=my_chat_model, embeddings=my_embeddings)
retriever = CoalentRetriever(cache=cache) # drop-in LangChain BaseRetriever
docs = retriever.invoke("what is our leave policy?")
docs[0].page_content # the served, attributed context payload
docs[0].metadata["read_id"] # -> cache.report_refusal() / report_success()
docs[0].metadata["cache_hit"] # True == served with zero LLM spend
cache.source_changed("policy.md", text=new_text) # surgical, provenance-keyed invalidation
Every Coalent knob passes through create_coalent_cache; the refusal→repair loop ships
as a runnable LangGraph-shaped example in the package. Depends only on coalent>=0.6 and
langchain-core>=0.3.
What's new in v0.7
The self-healing release — and the release that flips the default read path. The read now ships its own doubt, and the cache gains an explicit failure chain your agent drives — each rung fires only on a failed read, so a read that succeeds pays nothing new. One deliberate default changes (the read path, first item below); every NEW v0.7 knob is default-OFF and byte-inert until armed (pinned by tests). Full details in the CHANGELOG.
Measured on the same frozen news rig as every anchor since v0.5 (609 articles, 605 held-out questions, strict grading + locked adjudication rules): the full v0.7 composition scores 0.826 vs 0.774 for the strongest v0.6 configuration — +5.3 points at an identical ~983-token serving budget, final refusals −69% (61 → 19). Gating repair on failure matches always-on accuracy at 14% of the extraction calls.
The agentic loop — your evaluator decides, the cache heals:
cache = SemanticCache(
retriever, synthesizer, embedder=OpenAIEmbedder(),
# read_path resolves to "pool" automatically under a semantic embedder (v0.7 default)
gap_detector=True, # observe-only: the read reports its own holes
repair_extractor=my_extractor, # BYO callable(span, region, existing_claims) -> [claims]
)
r = cache.get(
question,
subs=planner_subquestions, # your planner's decomposition (optional)
constraints={"dates": ["2023-10-05"], "sources": ["TechCrunch"]}, # intent metadata (optional)
)
answer = my_answerer(r.context["pool"]) # your model, your prompt
r.sources # artifact ids behind the payload
r.max_source_age_s # freshness age of this serve
r.gaps # [{probe, span, source, kind}, ...] — the read's own doubt
if failed(answer): # the failure chain — each rung ONLY on failure
cache.repair(r.read_id) # re-extract what the build missed — PERMANENT
r2 = cache.get(question, subs=planner_subquestions) # repaired claims now compete
answer = my_answerer(r2.context["pool"])
if failed(answer):
r3 = cache.reprobe(r2.read_id) # entity-probe re-rank of the same pool
answer = my_answerer(r3.context["pool"]) if r3 else answer
if failed(answer):
r4 = cache.serve_unserved(r2.read_id) # last rung: force-pack admitted-but-unserved claims
answer = my_answerer(r4.context["pool"]) if r4 else answer
- BREAKING — the default read path resolves to pool.
read_pathnow defaults toNoneand resolves to"pool"whenever a semantic embedder is available — every keyed/real deployment (OPENAI_API_KEYset, or any non-lexicalembedder=). Pool is the measured path (every published v0.6/v0.7 number; the flip criteria were met by the 0.7 battery evidence — 0.826 vs 0.774 above). Keyless zero-config falls back to the unit path with a loud warning naming both remedies (setOPENAI_API_KEY/ passembedder=). Escape hatch: explicitread_path="unit"stays fully supported and byte-identical to the pre-0.7 default; an explicitread_pathalways wins over the resolution. - The read ships its own provenance and doubt.
Result.sources(the artifact ids actually behind the payload),Result.max_source_age_s(the serve's freshness age), and — withgap_detector=True—Result.probes/probe_coverage/gaps: per probe, whether a raw evidence sentence outscores every claim (extraction_hole→ repair terrain) or nothing reaches the probe (corpus_hole→ route to a tool). Observe-only by construction: serving is byte-identical ON vs OFF (pinned), and the sentence tier costs $0 at serve (lazy, embedded once, cached). repair(read_id)— the pump. Consumes the read's banked gap and constraint candidates plus bridge candidates near what served; one span-anchored BYO extractor call per candidate (the library still never calls an LLM itself); mechanical near-dup and defect rejection (antecedent-free pronoun subjects, truncated spans); then an append-only, provenance-stamped, permanent store improvement — the cost is paid once, every future read benefits. Returns aRepairReport.serve_unserved(read_id)andreprobe(read_id, hint=None)— the refusal rungs. Force-pack the claims that lost the packing race, or re-rank the unchanged pool with entity probes harvested from what served. Embeds only — no LLM, no retrieval, no store mutation — and by contract they run on refusals, so they cannot un-answer a correct read.subs=/constraints=onget(). Your planner hands the read its decomposition (subs=["...", ...]— wins over thedecompose=callable) and its metadata intent (constraints={"dates": ..., "sources": ..., "entities": ...}— AND across keys, OR within a key, falling back to OR rather than silencing a read). Constraints are a feeder only: they bank repair candidates and never touch pool scoring or serving (pinned).- Ingest metadata closes the v0.6 attribution gap.
retriever.add(..., meta={"title": ..., "source": ..., "date": ...})puts the metadata ON the unit (source_meta), and the default pool header renders the measured[title | source | date]golden path without thepool_headercallable. Meta-less ingests are byte-identical to 0.6. - Flip status: the pool-path default flip pre-registered in 0.6.0 is taken in
0.7.0 — on the 0.7 battery evidence and an explicit maintainer call (2026-09-15), in
place of the three pre-registered gates that were never run as specified. It is
conditional by design (pool requires a semantic embedder by contract, so the lexical
fallback stays on unit, loudly). Not a deprecation:
read_path="unit"stays fully supported with noDeprecationWarning, andserve="pool"(the v0.5 preview) survives unchanged in 0.7.
What's new in v0.6
The pool-first release. Every n=605 number below comes from one frozen rig — a 609-article news corpus, 605 held-out questions, gpt-4.1-mini answerer, strict grading — the same rig the v0.5 numbers were measured on. Full details in the CHANGELOG and UPGRADE-0.5-to-0.6.md.
read_path="pool"— the claim-pool-first read path (opt-in in 0.6; the resolved default since v0.7 under a semantic embedder). Reads are answered by budget-packing the global fresh-claim pool; units remain the ownership / freshness / provenance skeleton. Measured: 0.731 strict accuracy @ 981 mean context tokens — matching naive top-9 (0.711 @ 1,311) at ~25% fewer tokens and naive's best measured point (top-12: 0.731 @ 1,729) at ~43% fewer. The claim is parity at fewer tokens (CIs overlap) — not an accuracy beat. Gold-claim serving rank: p50/p75/p90 = 1/6/15 in pool order.- Attribution by default, and a measured header ladder.
pool_header=Nonenow renders a built-in per-source header. Same store, same queries: opaque id 0.641 → shipping default 0.678 → your[title | source | date]metadata callable 0.731. The gap is a unit-metadata limit (outlet/date live in your corpus, not on the unit) — wire the callable (quickstart above). - The behavioral stack (all default-OFF): spans → fallback → repair → keys.
residual_spans=Truecaptures fact-bearing sentences the extractor missed as tier-2 spans on the unit (never in the pool). When your answerer refuses,report_refusal(read_id)returns an attributed retry payload;report_success(read_id)confirms the rescue and — withquery_keys=True— earns a durable alternate key; lossy-marked units self-repair append-only on their next rebuild. Measured, driven through the full loop: refusals 91 → 61 (−33%), +3.1 pts final accuracy at +2.1% tokens (same-store comparison), zero newly-wrong answers; keyed-class first-pass 0% → 61% on paraphrase revisits. - Adaptive serve gate (
serve_gate=None) — adapts against the pool's own noise ceiling; an explicit float disables adaptation (reproducible benches). Shipped only after a $0 replay gate: 605/605 identical serve decisions on both arms, zero builds, zero LLM calls. - Hardening & plumbing: every payload surface carries source attribution (pool payload and escalation raw); cross-owner near-duplicate claims are kept as corroboration; 14 new observability events (
pool_served,residual_fallback,key_confirmed, ...);rerankerhook (serving order only — it can never cause a false serve);claim_indexBYO pool storage; a v0.5 pool-preview stale-serve hole is fixed. - Deprecated:
serve="pool"(the v0.5 preview) — still works verbatim in 0.6 and 0.7; migrate toread_path="pool". In 0.6 the default read path stayed"unit"(exact v0.5 behavior) behind five pre-registered flip gates — v0.7 took the flip (see What's new in v0.7).
Honest limits (measured, not hypothetical)
- The refusal fallback flips ~20% of natural refusals (33% when the payload contains the answer verbatim) — the 68% figure from lab questions holds only where the payload contains the answer by construction. It is a net over the extraction tail, not a second retriever.
- Query keys can collide across sibling articles in dense same-topic corpora (observed 3/605 reads; answers still correct). Raise
key_floorabove its 0.85 default there. Keys convert refusal round-trips into first-pass answers; they do not raise final accuracy on diverse rewordings. - The shipping default header can only attribute what the unit knows — the 0.678 → 0.731 gap is a unit-metadata limit, closed today by the
pool_headercallable; an optional ingest-time metadata field is a v0.7 item.
Coalent MCP questions
How do I add Coalent MCP to Claude Code?
Run claude mcp add --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'COALENT_MCP_TOKEN=<YOUR_COALENT_MCP_TOKEN>' coalent -- uvx coalent in your terminal. Add --scope user to make it available in every project.
How do I add Coalent MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
How does Coalent handle source updates?
It uses provenance-based invalidation, meaning when a source changes, only the specific cached units that used that source are invalidated and rebuilt.
Can I use my own vector database with Coalent?
Yes, Coalent sits above retrieval and allows you to bring any retriever, such as a vector DB, hybrid search, or APIs.
How do I use Coalent with Claude Code or Cursor?
You can install the coalent-mcp package and add it to your MCP client using the coalent-mcp command.
Does Coalent require an LLM to work?
Yes, it requires a synthesizer (LLM) to extract understanding and an embedder to match queries by meaning.