标签：#mcp

TL;DR codegraph , codebase-memory-mcp , and serena all got there first, handing a coding agent code intelligence over MCP so it stops grepping. On my own open-ended questions the token bill didn't budge: the agent kept sliding back to grep, and no amount of forceful prompting could stop it. So I built @ttsc/graph . It gives the agent an index the TypeScript compiler already resolved, never the source bodies, through a single tool with a forced chain-of-thought. On "how does this work?" questions that works out to roughly 10× fewer tokens, and the answers are no worse. That figure is a median, and a conservative one. Repository: https://github.com/samchon/ttsc Benchmark: https://ttsc.dev/docs/benchmark/graph 1. Preface 1.1. What @ttsc/graph Is On the left, the agent is lost in a maze of files, chasing dashed arrows dozens deep. On the right, it's reading a single compiler-built graph of nodes and edges, with the file:line anchors it can open and check. You're new to a TypeScript repo, so you ask the agent for a tour: what's the main runtime flow, from the public API down to the code that does the work, and what should you read first? You know how it goes. It opens a file, follows an import into another, then another, and a few dozen files later it gives you an answer. @ttsc/graph cuts that crawl short. Over MCP, it hands your agent a graph of your TypeScript codebase that the compiler itself drew: what calls what, what depends on what, and where each piece lives. The agent answers structural questions straight from the graph instead of spelunking through files, and every claim it makes points at an exact file:line the compiler resolved. Nothing invented, just a location you can open and check for yourself. It's the same question and the same agent in every case, and only @ttsc/graph stays flat across the repos no matter how big they get. The other three, codegraph, codebase-memory, and serena, swing all over the place, and a few even spend more than the baseline does

What Claude Sonnet 5 Means for AI Infrastructure in East Africa The release of Claude Sonnet 5 on June 30, 2026 changes something specific about building AI agent infrastructure for regions like East Africa: the model tier that couldn't reliably finish a multi-step workflow now can. This isn't a general AI update note. It's about a concrete technical constraint that just moved. The constraint that moved East Africa's AI infrastructure problem isn't compute or APIs. M-PESA has an API. Africa's Talking has an API. NDMA publishes drought data. KRA has a taxpayer portal. The constraint has been that an AI agent calling several of these in sequence — check drought severity → trigger insurance evaluation → notify county — would stop partway through, lose context, or require manual handholding to continue. Sonnet 4.6, released in February, scored 67.0% on Terminal-Bench. Sonnet 5, released today, scores 80.4%. That 13-point gap isn't abstract. It's the difference between an agent that stalls at step two of a cascade and one that finishes. What this means for the East Africa coordination stack The 31 MCP servers in this portfolio — covering M-PESA, drought data, tax, credit scoring, crop insurance, land records, labor rights, county data, and more — are now meaningfully more useful as a system than they were yesterday. The key change: africa-coord-bus , the coordination event bus that connects these servers, is now the kind of tool Sonnet 5 was designed to orchestrate. A drought alert from wapimaji-mcp , cascading through bima-mcp for insurance evaluation and county-mcp for notification, is exactly the multi-hop tool chain where the 13-point Terminal-Bench improvement shows up in practice. The model to use # Claude API client = anthropic . Anthropic () response = client . messages . create ( model = " claude-sonnet-5 " , max_tokens = 1024 , tools = [...], # your MCP tools messages = [{ " role " : " user " , " content " : " ... " }] ) For compliance and vulnerability analysi

Most "agent memory" and "agent context" tools today require sending your data to someone else's cloud. If you operate in a regulated, air-gapped, or simply privacy-conscious environment, that rules them out before you've even tried them. I build the opposite: two MIT-licensed, local-first MCP servers that do this work entirely on your own hardware. The problem Agent memory and context assembly are converging on a cloud-only default. That's a non-starter for defense, healthcare, finance, legal, and any team that can't or won't let agent context leave their VPC. It's also just slower and less deterministic than it needs to be: agents re-discover the same facts about your repo and services every session, burning tokens and turns before doing any real work. Mimir: persistent memory, fully offline Mimir is a single ~8MB Rust binary. It encrypts everything at rest with AES-256-GCM, and it works with no API key, no model download, and no network access at all, because the embeddings used for dense search are bundled directly into the binary. It's bi-temporal: every fact carries a validity window, so you can query memory "as of" any past point and supersede facts without deleting history. 43 MCP tools, SQLite + FTS5 hybrid search under the hood. One honest tradeoff worth naming: the FTS5 index needed for fast keyword search currently sits over plaintext, even though the underlying record is encrypted at rest. We're upfront about this in the docs rather than overstating the encryption story. Perseus: compile-before-context Perseus takes a different approach to context than runtime tool-call discovery. Instead of letting an agent rediscover your git state, running services, and test status through a chain of tool calls every session, it compiles all of that into a ready briefing the moment a session starts. The result is deterministic and byte-stable: the same repo state always produces the same compiled context. Honest, reproducible benchmarks On paraphrased queries, Mimir's

I got tired of manually writing MCP tools for every REST endpoint I wanted to expose to an LLM. So I automated it. mcpgen reads an OpenAPI JSON or YAML file and generates a complete, ready‑to‑run MCP server in Python. 🔧 What it does Parses OpenAPI 3.0 / 3.1 specs Creates one MCP tool per endpoint (with snake_case names) Handles auth automatically (API key, Bearer, etc.) Outputs a clean, human‑readable Python script Zero runtime surprises – just mcp and httpx 🚀 Quick start bash pip install mcpgen mcpgen my-api.json -o my-mcp-server python my-mcp-server/server.py The generated server runs over stdio – ready to plug into Claude Desktop or any MCP client. 🧪 Real‑world test Recently a contributor added an OpenAPI 3.1 fixture (Xquik API) with lookupTweet and getUser endpoints. The tool generated the correct tools, including path parameters and x-api-key auth, on the first try. All 18 tests pass. It works. 🤔 Why you might want it If you’re building LLM agents that need to interact with APIs, mcpgen eliminates the boilerplate. You don’t have to write a single @app.tool() decorator by hand. It also makes it dead simple to experiment – change your API spec, regenerate the server, and you’re done. 📦 Links GitHub: JnanaSrota/mcpgen PyPI: pip install mcpgen MIT licensed, open to contributions 🙏 Feedback If you try it with your own API spec and something breaks (or works beautifully), I’d love to hear about it. Drop a comment or open an issue. Thanks for reading!

Artificial Intelligence is rapidly evolving from chatbots to autonomous agents capable of...

Elastic open-sourced Atlas, a system built on Elasticsearch that maintains three categories of memory for agents. Atlas integrates with agents via MCP and maintains per-user isolation of memories. When evaluated on question-answering capability, it scored 0.89 Recall@10. By Anthony Alford

This article covers the MCP setup and configuration for using Google Nano Banana 2 Lite and...

A new standard for autonomous-agent commerce now has a live implementation, and it's worth reading closely - not because it competes with atomic settlement, but because it draws the line between two settlement philosophies more clearly than anything I've seen so far. The standard is ERC-8183 , the Agentic Commerce Protocol, launched earlier this year by the Ethereum Foundation's dAI team and Virtuals Protocol. The implementation is BNB Chain's BNBAgent SDK , which the team describes as the first live build of the spec (shipped on testnet in March 2026, mainnet pending). If you build for AI agents, both are worth understanding on their own terms. They're also the clearest mirror I've found for explaining what "atomic settlement" actually means. What ERC-8183 does ERC-8183 models commerce as a job with an escrowed budget . There are three roles: a Client who posts the job and funds it, a Provider who performs the work, an Evaluator - a designated third party who decides whether the work was completed. The job moves through four states: Open → Funded → Submitted → Terminal . The client funds the budget into escrow. The provider submits a deliverable. Then the evaluator - and only the evaluator - attests that the job is complete (or rejects it), and the escrow releases accordingly. If the job expires, the client gets refunded. This is a sensible design for a real class of problems. A lot of agent "commerce" is genuinely work-for-hire: do a task, produce a deliverable, get paid if it's acceptable. Acceptability is subjective, so you need someone to judge it. ERC-8183 makes that judge a first-class role and standardizes the lifecycle around it. BNBAgent SDK goes further and routes disputes through UMA's data-verification mechanism, adding an arbitration layer the base spec deliberately leaves out. So far, so reasonable. The interesting part is the assumption baked into the shape of it: someone has to decide that the deal is done. What atomic settlement removes Now hold th

How I let non-engineers ship AI tools to production — and the boring infrastructure that made it safe. A product manager described a workflow in plain English — "every morning, pull yesterday's failed payments, group them by error code, and post a summary to our channel." Twenty minutes later it was running in production. She never opened an editor. She never saw a line of TypeScript. She talked to an agent, the agent wrote the code, and — once a human had reviewed the pull request — it shipped. That sentence should make you nervous. It made me nervous, and I'm the one who built the thing. The demo is "look, it wrote the code." The operation is "a marketer's tool now has a path to the payments database and nobody reviewed it." The interesting engineering isn't the part where an LLM writes code — that's the easy, demo-able part. It's the guardrails that decide whether the code it writes is allowed to exist. Here's the platform, and the five problems I had to solve to make it safe to hand to people who can't read the code that runs. The shape of the thing The platform is a place where anyone — engineers, PMs, designers, QA — can publish a reusable AI tool, and everyone else can use it. Write once, available to all. A few terms up front, because the whole design leans on them: MCP (Model Context Protocol) is a standard way for an AI client to discover and call your functions. The key detail: there's a step where the client asks the server "what tools do you have?" and the server answers with a list. Hold onto that — half the design hangs off that one list. Cloudflare Workers is code that runs on Cloudflare's servers at the network edge instead of your own. Durable Objects is per-session server-side storage that lives outside the model's context — the finite, token-costing window of everything the model can currently see. None of this is exotic; what matters is where each piece of state lives. Under the hood it's three small Workers speaking MCP: a gateway (auth, routin

From knowing to doing — Phase 4 of the Jarvis AI Platform The Problem with Knowledge-Only AI After Phase 3, Jarvis could remember you across sessions and search your documents. But it still had a fundamental limitation. You: "What is the weather in Kathmandu right now?" Jarvis: "I don't have access to real-time weather data." You: "What is 2847 × 391?" Jarvis: "The answer is approximately 1.1 million." ← WRONG An AI that only knows things from training data is useful. An AI that can do things is transformative. That is what Phase 4 built. What Is a Tool Engine? A tool engine gives the AI model the ability to call real functions during a conversation. The flow looks like this: User: "What is the weather in Kathmandu?" ↓ AI Model ↓ "I should call WeatherTool" ↓ WeatherTool.getWeather("Kathmandu") ↓ "22°C, Clear sky, Humidity: 45%" ↓ AI Model ↓ "The weather in Kathmandu is 22°C and clear." The key insight: the AI decides when to call a tool and with what input . We don't hardcode "if user asks about weather, call WeatherTool." The model figures that out from the tool descriptions we provide. The Architecture Decision The most important architectural decision in Phase 4 was the package structure. ai . jarvis . tools / ├── JarvisTool . java ← marker interface ( root ) ├── ToolRegistry . java ← manages all tools ( root ) ├── builtin / ← built - in tools │ ├── DateTimeTool . java │ ├── CalculatorTool . java │ ├── WeatherTool . java │ └── WebSearchTool . java └── mcp / ← MCP protocol └── McpServerConfig . java Why not put tools inside ai/ ? The ai/ package handles HOW Jarvis talks to AI models. Tools define WHAT Jarvis can do. These are fundamentally different responsibilities. Mixing them would mean every new tool requires changes to AI infrastructure code. Keeping them, separate means adding a new tool requires exactly one file. The JarvisTool Pattern Every tool in Jarvis implements one interface. /** * Marker interface for all Jarvis tools. * Spring auto-discovers all @C

If you have built an estimate in the AWS Pricing Calculator by hand, you know the drill. Open calculator.aws, search a service, click in, stare at twenty fields half of which you do not need, guess at the ones the form does not explain, pick a region, repeat for every service. Then redo the whole thing next week when the customer asks what it looks like in Frankfurt. For presales that is not a small annoyance. It is the gap between giving a number on the call and saying "let me get back to you." I wired the AWS Pricing Calculator MCP into Claude, and the first real estimate I built took one sentence. What it is An MCP server - an AWS Samples project - that exposes the Pricing Calculator as tools an agent can call. You describe the workload, the agent assembles the estimate, the server saves it to the real calculator, and you get a shareable calculator.aws URL back. Same link you would have built by hand, minus the form. Three things make it usable in front of a customer: No AWS credentials. It hits the public, unauthenticated calculator.aws endpoints. You are not pointing it at an account or assuming a role. There is no blast radius. Live definitions. It pulls the calculator manifest at runtime - about 436 services - so it is current, not a snapshot from six months ago. Real, editable estimates. The URL it returns opens in the actual calculator. Tweak it, send it, whatever. The agent just did the boring part. It runs over stdio for local clients like Claude Desktop, Kiro, and Cursor, or over HTTP ( MCP_TRANSPORT=http ) if you want it hosted. It also handles the aws-iso and aws-eusc partitions, which matters for sovereign and regulated work. Context is the whole job The honest part: it is amazing when you feed it the right context . Ask for "an estimate for a web app" and you get back a web app someone else imagined. The calculator never knew your traffic - you did. The MCP does not change that. What it changes is the translation. Once you know the shape - two m5.lar

What are MCP Servers? The Model Context Protocol (MCP) is an open standard that lets AI agents use external tools through a unified interface. Think of it as USB-C for AI — one protocol connects any AI client (Claude Desktop, Cursor, VS Code with Cline) to any tool or data source. I built three production-ready MCP servers and published them to PyPI and GitHub. Here's what they do and how to use them. 1. Web Search MCP Server uvx crewai-web-search-mcp Two tools: web_search(query) — Searches Google/SerpAPI and returns ranked results with snippets extract_content(url) — Fetches and extracts readable content from any web page Use cases: Ask your AI about current events, research competitors, pull documentation, verify facts in real time. { "mcpServers" : { "web-search" : { "command" : "uvx" , "args" : [ "crewai-web-search-mcp" ] } } } 2. Code Review Automation MCP uvx code-review-automation Three tools: review_code(diff) — Analyzes code changes for bugs, security issues, anti-patterns, style violations check_quality(path) — Runs static analysis and returns a quality report analyze_pr(diff) — Produces a structured review: what changed, what's risky, suggestions Use cases: Paste a PR diff and get an instant review. Catch issues before they reach production. 3. Document Intelligence Server uvx document-intelligence-server Three tools: extract_document(path) — OCR and text extraction from PDFs, scanned docs, images classify_document(path) — Identifies document type (invoice, report, contract, article) summarize_document(path) — Generates a structured summary from extracted content Use cases: Process uploaded PDFs, extract data from scanned forms, summarize long reports. Pricing All three servers use a shared credit system: Tier Price Credits Free $0 50 calls/day Starter $20 2,000 calls Pro $100 12,000 calls Buy credits once, use them across any server. Credits never expire. How it works: Install with uvx crewai-web-search-mcp Use 50 free calls per day — no key needed For u

I've been building agent workflows for a while, and one capability keeps coming up that the ecosystem hasn't fully reckoned with: letting an AI agent publish a document to the public internet and hand someone a link. It sounds trivial ("save HTML, return a URL"). It isn't. The moment an autonomous agent can mint a public link, you've handed it a primitive that touches access control, data exposure, and reputation. This post is about the design questions that surface once you take that seriously, written by someone who builds in this space. Disclosure up front: I work on Thryvate, a document-sharing tool with an MCP server. More on that at the end, but the problems below are general. The naive version The first version everyone writes is a tool that takes content and dumps it to object storage behind a public CDN URL: publish(html) -> https://cdn.example.com/a8f3c2.html Ship that and an agent can now share its work. It can also now: expose a half-finished draft to anyone who guesses the URL, leave that URL live forever with no way to pull it back, publish something containing a customer's name with zero record of who saw it. For a human hitting "publish" deliberately, those are acceptable defaults. For an agent doing it as one step in a longer plan, they're landmines. What "publish" should actually mean for an agent A few properties turn the naive primitive into something you'd trust an agent to call: 1. Default to private, opt into public. The safe default for an agent-minted link is not "world-readable." It's "only people on this list" or "only people with the password." Public should be an explicit parameter someone has to set, not the fallback. 2. Revocability. Anything an agent publishes, you must be able to un-publish instantly. A live link is a liability with a half-life, and the ability to revoke is what makes it safe to let the agent create them liberally. 3. Expiry as a first-class field. "This link dies in 7 days" should be a parameter on the publish call,

Introduction — On What I've Been Writing for Years This is a follow-up to my previous post on Claude and MCP . Just sharing some recent thoughts. Personally, I've always enjoyed keeping records and analyzing my own work. So for years, I've been logging my daily tasks, jotting down thoughts, hesitations, and impressions in notes. I've drawn on these records for reviews, analysis, and decisions on various projects. The tools have shifted over time — Evernote, Notion, Logseq, Taskuma, and so on — but the habit itself, of writing notes into some app or tool, has stayed with me for years. What Happened with MCP I recently wrote about connecting Notion and Google Docs through MCP, and the results have surprised even me. I won't repeat the details here since they're in that post, but ever since I introduced MCP, the flow of information has accelerated dramatically. In particular, I'd been accumulating reviews, task management notes, and brainstorms in Notion for years, and letting Claude read all of this has shifted the meaning of what I'd previously written. When I first started recording in Notion, it never occurred to me that it might be useful to AI. Of course — I had no way to imagine a time when AI would become this close to everyday life, used in this way. I was just writing for plain, analog reasons — "so I could look back later," "so I could organize my own thinking." But the moment MCP made it all readable, the feeling shifted. It's as if my past self comes forward to help my current self. Claude answers my current questions while drawing on the reasoning behind old project decisions, or on impressions I'd noted at the time. I've had moments like that more than once now. Thinking about it: the human brain's memory has limits — even the person who wrote something forgets it quickly. That's why I kept taking notes, leaving behind my thoughts and conclusions at each point in time as a record. And now, in the flow of conversation, AI reads from those records, distill

Vercel has released Eve, an open-source framework for building, deploying, and operating AI agents in production. The framework uses a filesystem-based project structure to organize agent instructions, tools, skills, subagents, communication channels, and scheduled tasks, enabling developers to define agent behavior while reducing the amount of supporting infrastructure they need to implement. By Daniel Dominguez

Most discussions around MCP focus on tool calling. That is natural. When people first see MCP, the obvious use case is simple: Let the AI call external tools. A model can read a GitHub issue. A model can query a database. A model can update a file. A model can call an API. In that sense, MCP looks like an RPC layer for AI agents. That is useful. But I think it may not be the most important use of MCP. The more interesting use is this: MCP can distribute context, rules, skills, and operating contracts to AI clients. In other words, MCP is not only a way for AI to call tools during work. It can also be a way to define the working environment before the work starts. The problem with RAG RAG is usually used to answer this question: What information might be relevant to this request? The system searches documents, retrieves chunks, and gives them to the model. This works well for many cases. But it has structural limits. RAG retrieves likely relevant information. It does not necessarily define how the work should be done. For team-level AI work, this is a problem. A team does not only need information. A team also needs shared rules. For example: What is the authoritative source? What should be treated as unknown? When should the AI stop? When is human confirmation required? What is the closure condition? Which workflow should be used? Which domain skill applies? What evidence must be recorded? RAG can retrieve documents that describe these rules. But retrieval is not the same as governance. A retrieved chunk is just context. It is not necessarily an operating contract. The problem with local prompts Many teams try to solve this with prompts. They write instructions like: Follow our coding rules. Use this design document. Ask questions when unclear. Do not make risky changes. This helps, but it does not scale well. Each developer may have a different local prompt. Each AI client may load a different file. Each repository may contain a slightly different version of the ru

"Model unit prices keep falling, yet our monthly AI bill keeps climbing." If you use AI personally, you can feel the creep of your subscription and metered charges. If you own AI usage inside a company, the gap is even more pronounced. Overseas, this feeling has started getting a name: Tokenomics . On June 3, 2026, the Linux Foundation announced its intent to launch the Tokenomics Foundation , dedicated to open standards for AI cost management. Google, Microsoft, Oracle, JPMorganChase, and others — both providers and large buyers — are on board. https://www.linuxfoundation.org/press/linux-foundation-announces-the-intent-to-launch-the-tokenomics-foundation-to-establish-open-standards-for-ai-cost-management This post isn't an explainer of the word itself. It's an account of what changes for the people who own internal generative AI usage — the platform owners, the FinOps practitioners, the engineering leaders watching the bills — once you have this word in your vocabulary. What Tokenomics gives you isn't another saving technique. It changes the unit of measurement and the lens through which you read AI cost. Why Tokenomics, why now Tokenomics sits in the lineage of cloud FinOps. The FinOps Foundation now classifies Tokenomics as the "AI Value" dimension within FinOps for AI . Where cloud FinOps tracked the variable infrastructure costs (compute, storage, networking) against value, Tokenomics tracks the variable cost of intelligence itself. It's not a replacement; it adds a probabilistic, non-deterministic layer of variable cost on top. Tokens here means what you see on every API price sheet and usage dashboard — the smallest unit a language model reads and writes, the unit of compute. The word "tokenomics" also exists in the crypto world, but that one is about issuance, distribution, and incentives on a blockchain — tokens as units of ownership. Same word, different economies. https://www.finops.org/insights/token-economics-the-atomic-unit-of-ai-value/ The term gained

I wanted to tell my girlfriend 'I missed you today' in Farsi and have it sound like something a person would actually say, not a phrase pulled from a travel guide. Every tool I tried — Google Translate, DeepL — gave me one answer. No register. No note on whether it was too formal for a text message or too casual for a letter. Just a string of words and the implication that language has one correct answer per sentence. So I built konid: it returns three options for anything you want to say, ordered casual to formal, each with the register explained and the cultural nuance between them described. It also plays audio pronunciation through your speakers directly, using node-edge-tts — no API key, no copy-pasting into a separate tab. The interesting engineering constraint was deployment target. I wanted this to live where I already work, not in a separate browser tab I forget to use. That meant MCP. A single MCP server running at https://konid.fly.dev/mcp now serves four clients without any client-specific code: # Claude Code claude mcp add konid-ai -- npx -y konid-ai # ChatGPT (Developer mode, Actions) # endpoint: https://konid.fly.dev/mcp Cursor, VS Code Copilot, Windsurf, Zed, JetBrains, and Claude Cowork all connect the same way. The server doesn't know or care which client called it. The output structure for a query like 'I missed you today' in Japanese looks roughly like this: Option 1 (casual): 今日会いたかった Register: intimate, fine for close friends or a partner Note: dropping the subject is natural here; adding あなたに would feel stiff Option 2 (neutral): 今日、あなたのことが恋しかったです Register: polite, appropriate for someone you're close to but addressing respectfully Option 3 (formal): 本日はお会いできず、寂しく思っておりました Register: formal written Japanese; would be unusual in a personal context The nuance comparison is the part I couldn't get anywhere else. Knowing that option 3 exists and that you would almost never use it for a personal message is actually load-bearing information if you're l

MCP + RAG: Why I Stopped Building Complex RAG Systems After MCP Changed Everything Honestly, I've spent the last four years building increasingly complex RAG systems. Chunking strategies, embedding models, vector databases, rerankers, hybrid search... you name it, I've probably wasted a weekend trying it. I had this 1,800-hour knowledge base project called Papers — six years of notes, articles, bookmarks, everything. I built RAG version after RAG version, each time thinking "this time it'll be perfect." Spoiler: It never was. Then I added MCP (Model Context Protocol) support. And I realized something that completely changed how I think about knowledge retrieval: MCP makes traditional complex RAG obsolete for most use cases. Let me explain what I learned the hard way. The RAG Trap I Was Stuck In If you've built a RAG system, you know the drill: Chunking : Should you use fixed-size, semantic, recursive, or something fancy like LLM-powered chunking? Embeddings : OpenAI text-embedding-3-large vs Cohere vs nomic-ai vs your fine-tuned model? Vector Database : Pinecone vs Weaviate vs PGVector vs Qdrant vs Chroma? Retrieval : Top-k how many? Hybrid search with keywords? Reranking? Prompt Compression : How do you fit all the retrieved chunks into the context window? I went through every iteration. At one point, my RAG system was over 2,000 lines of code. I had configurable chunkers, multiple embedding providers, caching layers, hybrid search... it was impressive. It also didn't work that well. Here's what bothered me the most: I kept throwing more complexity at the problem, but the fundamental issue never went away. I was trying to make my knowledge base smart, but AI already got smart. Why was I reimplementing all this understanding logic when the AI can already do it better than me? How MCP Changed the Game When I added MCP support to Papers, I started with the simplest possible approach: Expose two tools: search_notes and get_note_content Search is just basic text matchin

I 've been using Cursor on non-trivial repos and kept hitting the same issue: the agent finds a file but misses routes, shared modules, and tests that should run after a change. I built FlowIndex — a local CLI + MCP server that scans a repo and builds a behavior graph in SQLite (entrypoints, imports/calls, tests, git co-change). No embeddings, no SaaS, no LLM calls in the index itself. Setup: pip install "flowindex[mcp]" In your project: flowindex init flowindex scan Add to ~/.cursor/mcp.json (use your repo' s absolute path for cwd ) : { "mcpServers" : { "flowindex" : { "command" : "flowindex" , "args" : [ "mcp" ] , "cwd" : "/absolute/path/to/your/repo" } } } 4. Restart Cursor — you get tools like get_change_impact, suggest_tests, make_context_pack, explain_entrypoint, get_repo_overview. Example workflow: before editing payments/ledger code, ask the agent to use make_context_pack or get_change_impact on that file — it pulls from the local graph, not a generic file search. Honest limits: static analysis + git heuristics only. Call paths resolve via imports but aren 't compiler-grade. TS/JS is heuristic. Documented in the README. MIT · pip install flowindex · https://github.com/adu3110/flowIndex Curious if others use MCP for repo context and what tools you wish existed. Happy to fix setup issues if anyone tries it.