The answer, and the wire that delivers it.

Stage 4 done right (cited synthesis + gap analysis), and how the agent actually calls the brain over MCP.

Spaced recall (L7): the two axes that pick an architecture? Question shape and data velocity. Now we finish the pipeline: what happens to the retrieved chunks, and how the agent reaches them at all.

The one idea: Retrieval (L2-L7) ends with the best chunks. Synthesis turns them into a cited answer that also states what it does not know. And none of it reaches your agent without a wire: MCP is the standard plug that lets Claude Code or Cursor call the KB as tools.

Synthesis: answer + citations + gaps

This is the move that earns the slogan "search gives you raw pages, the KB gives you the answer." Three parts, and the third is the one people skip:

Part	What it is	Why it matters
Answer	LLM composes prose from retrieved chunks	The user wanted a conclusion, not a list
Citations	Each claim links to its source chunk	Trust + verifiability. No citation, no trust
Gap analysis	Explicit "the brain doesn't know X yet"	Stops confident hallucination; flags what to ingest next

Gap analysis is the quiet superpower. A KB that says "I have no source on Patong's December numbers" is more useful than one that invents them. It also tells you exactly what signal to capture next, closing the loop back to stage 1.

Grounding beats fluency

The synthesis prompt's job is to keep the LLM on the retrieved evidence. Every sentence should trace to a chunk. If it can't, the answer should say so rather than fill the gap from training data. This is the difference between a brain (grounded, citable) and a chatbot (fluent, unaccountable). For a client deliverable, ungrounded synthesis is a liability, not a feature.

MCP: the wire

MCP (Model Context Protocol) is the standard that lets an agent call external tools. The KB exposes tools like search, write_page, get_entity; the agent calls them mid-conversation. Two transports:

stdiolocal. KB runs on your machine, agent pipes to it.

HTTP + OAuthremote. Hosted KB, scoped access, teams.

This is why gbrain advertises "paste an install URL into Claude Code, Cursor, ChatGPT." That URL points at its MCP server. It is also exactly how your Graphiti memory reaches Claude Code: the /prime and /handoff commands call MCP tools under the hood. You have been using MCP this whole time.

Connect it back, full circle: the five stages from Lesson 1 are now complete in your head. Ingest (L4) → store (L4-L6) → retrieve (L2-L7) → synthesize (this lesson) → link (L5-L6), all reachable by the agent over MCP (this lesson). You can now draw the entire machine from memory. That was tier-1 of the mission.

Retrieval practice

What part of synthesis most reduces confident hallucination?

What does MCP provide in a knowledge-base setup?

How does your Graphiti memory already reach Claude Code?

Read this next (primary source)

★ garrytan/gbrain README. Read it now, end to end. With Lessons 1-8 done, every section ("hybrid search", "auto-wired graph", "MCP stdio/HTTP", "synthesis with gaps") should read as familiar machinery, not jargon. That comprehension is the checkpoint before the hands-on lessons.

Ask your teacher. Try: "show me the actual MCP tools my Graphiti server exposes", "write a synthesis prompt for a DuckyCutz KB that refuses to guess", or "I read the gbrain README, here's what still doesn't click..." Then say "lesson 9" to start the hands-on phase.

← Lesson 7: Vector vs Graph vs Hybrid Next → Lesson 9: APPLIED — master your Graphiti graph