Codewalk MCP server
Commit Aug 23, 2026Enables AI agents to analyze codebases using dependency graphs, RAG, and tree-sitter parsing to provide architectural insights and automated code reviews.
Also known as gupta29470/codewalk
- Stars
- 5
- Tools
- 8
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Aug 23, 2026
- License
- MIT
What is Codewalk MCP?
Codewalk enables AI agents to analyze codebases using dependency graphs, RAG, and tree-sitter parsing to provide architectural insights and automated code reviews. It exposes 8 tools, such as codewalk_analyze_codebase, codewalk_generate_config, codewalk_find_circular_dependencies.
Summary generated from the project's README
About Codewalk MCP server
Codewalk provides a codebase intelligence layer designed for developers and AI agents to understand complex repositories. It functions as an MCP server that integrates with tools like Claude Code, Cursor, and VS Code Copilot, allowing these agents to access deep architectural insights. The system builds a persistent dependency graph using tree-sitter parsing and DuckDB to map imports, detect cycles, and calculate centrality across over 15 programming languages.
Users can interact with their code through a Web UI for visual exploration or via a REST API for CI/CD integrations. The server utilizes Corrective RAG and vector databases to provide grounded answers while minimizing token costs. It also features a voice interface for hands-free interaction. For security and quality, it offers an automated code review pipeline that evaluates git diffs for bugs and OWASP compliance, providing specific blast radius warnings to show how changes might impact the wider system.
What you can do with it
- 1Assess change impactDetermine which parts of the system will break if a specific file is modified.
- 2Automate pull request reviewsRun an automated review on git diffs to identify security risks and architectural bottlenecks.
- 3Onboard to new repositoriesGenerate a logical reading order and module map to understand a new codebase quickly.
Written from the project's README. Every use case is checked against a quote from it.
Codewalk MCP tools 8
Detected from the READMEcodewalk_analyze_codebasecodewalk_generate_configcodewalk_find_circular_dependenciescodewalk_get_architecture_healthcodewalk_get_review_detailscodewalk_accept_and_verify_fixcodewalk_run_static_analysiscodewalk_run_tests
| codewalk_analyze_codebase | — | |
| codewalk_generate_config | — | |
| codewalk_find_circular_dependencies | — | |
| codewalk_get_architecture_health | — | |
| codewalk_get_review_details | — | |
| codewalk_accept_and_verify_fix | — | |
| codewalk_run_static_analysis | — | |
| codewalk_run_tests | — |
Configuration
CODEWALK_PATHCODEWALK_REPO_NAMECODEWALK_REPO_TOKENCODEWALK_SERVER_URLEMBEDDING_MODELLLM_MODELLLM_PROVIDER
| Name | Description | |
|---|---|---|
| CODEWALK_PATH | — | |
| CODEWALK_REPO_NAME | — | |
| CODEWALK_REPO_TOKEN | — | |
| CODEWALK_SERVER_URL | — | |
| EMBEDDING_MODEL | — | |
| LLM_MODEL | — | |
| LLM_PROVIDER | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablegupta29470/codewalk is public and reachablegithub.com/gupta29470/codewalk ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-08-23github.com/gupta29470/codewalk ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model8 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubWhat is Codewalk?
Codewalk analyzes any codebase and gives you:
- Module detection — groups files into logical modules automatically
- Dependency graph — extracts every import/require → builds the full dependency map
- Blast radius — "if I change this file, what breaks?"
- Reading order — optimal file reading sequence (dependencies first)
- Execution flow — entry points, module-to-module and file-to-file dependency flow
- AI chat — ask anything about the code, powered by RAG + tool-calling agent
- Code review — review git diffs for bugs, security issues, and style (context-enriched, OWASP-focused)
- Incremental reindex — re-embed only changed files using content hash comparison
- Graph intelligence — DuckDB + igraph: symbol-level call graph, cycle detection, centrality analysis, import chain tracing
- Corrective RAG — distance-based chunk filtering + LLM answer grading + query rewriting for higher quality answers
- Voice interface — talk to your codebase hands-free: mic → transcribe → Copilot routes → speak answer
Three ways to use it locally, plus optional cloud indexing:
| Interface | Best for |
|---|---|
| Web UI (Next.js) | Visual exploration — Knowledge Graph UI, diagrams, module browser, blast radius viewer |
| MCP Server | VS Code Copilot, Claude Code, Cursor — AI agents use tools directly |
| REST API | Scripts, CI/CD, custom integrations |
Cloud (optional): Push to GitHub → Codewalk Cloud indexes on the server → MCP downloads the index and queries locally. See Cloud Deployment.
🎙️ Voice is available via both MCP (
codewalk_voice_ask+codewalk_speak) and REST API (POST /voice/ask) — ask questions by speaking, hear answers read aloud.
Why Codewalk?
| Scenario | How Codewalk helps |
|---|---|
| New dev joins the team | Point Codewalk at the repo → get an overview, module map, and reading order. Self-onboard in hours instead of weeks of "hey, can you explain this?" |
| LLM token costs are high | Without RAG, the LLM needs your entire codebase in context — slow and expensive. Codewalk embeds code into a vector DB and retrieves only the relevant chunks per query. Faster answers, fraction of the tokens. |
| Senior dev switches modules | You know the auth module but now need to work on payments. Get module info, blast radius, and execution flow without bugging the payments team. |
| Before a refactor | Check blast radius before touching shared code. "If I change base_model.py, what breaks?" — get the answer before you break prod. |
| PR reviews | Run codewalk_run_review (MCP) or POST /review (API) — automated review with OWASP security checks, blast radius warnings, and team guidelines matching. MCP mode returns enriched context so the calling model (Claude/GPT) performs the review directly — no separate LLM needed. |
| Documentation is outdated | Codewalk analyzes the actual code, not stale wiki pages. Always up to date. |
🔬 Code Review — Powered by the Intelligence Layer
Codewalk's review engine is built on top of the codebase intelligence layer. It doesn't just lint — it understands your architecture, knows what files are risky, and reviews with full context.
How it works
git diff → Static Analysis (graph risk, PageRank, cycles, blast radius)
→ Batch files (3-5 per batch, grouped by feature)
→ Host LLM reviews each batch with full context
→ Submit findings to disk per batch (JSON + Markdown, context stays clean)
→ Final summary: raw findings grouped by severity
What makes it different
| Capability | CodeRabbit / GitHub Copilot Review | Codewalk Review |
|---|---|---|
| Architecture awareness | ❌ No dependency graph | ✅ DuckDB + igraph: PageRank, fan-in, cycles, bottlenecks |
| Blast radius | ❌ | ✅ "This file has 23 callers — review with extra care" |
| Works without indexing | — | ✅ Just needs a git repo (graph enhances but isn't required) |
| Batched for large PRs | Dumps everything at once | ✅ 3-5 files per batch, sorted by risk, host LLM stays focused |
| Custom rubrics | Limited | ✅ Per-language + per-framework + team guidelines |
| Fix application | Suggests only | ✅ Accept/reject → apply atomically → verify with tests |
| Severity levels | varies | blocker · error · suggestion |
Zero-setup review
Review runs on any git repo — no codewalk_analyze_codebase needed. The dependency graph is built automatically on first review (~5s) and cached:
| Component | Auto (graph-only) | Full index (after analyze) |
|---|---|---|
| Git diff + file content | ✅ | ✅ |
| Rubrics + team guidelines | ✅ | ✅ |
| Stack detection | ✅ (from file extensions) | ✅ (cached) |
| Blast radius, PageRank, cycles | ✅ Built on-the-fly (~5s) | ✅ From cached DuckDB |
| Neighborhood (callers, tests) | ⚠️ Tests + interfaces only | ✅ Full (from ChromaDB) |
| Blast radius warnings | ⚠️ Not available | ✅ Transitive impact |
Severity levels
| Level | Value | Meaning |
|---|---|---|
| Blocker | "blocker" |
Must fix before merge — blocks the PR |
| Error | "error" |
Should fix — real bugs, logic errors, security risks |
| Suggestion | "suggestion" |
Nice to have — style, naming, minor improvements |
MCP review flow
codewalk_run_review()→ session + first batch (reviews ALL changes by default: staged + unstaged + untracked; passtarget_branch='...'to diff against a branch)- Host reviews batch →
codewalk_submit_batch_findings(session_id, [...])→ saved to disk as JSON; a hard-wrapped Markdown companion is also written for easy reading codewalk_review_next_batch(session_id)→ next batch (context window is clean)- Repeat until all batches done
codewalk_get_review_summary(session_id)→ structured summary of raw findings- User edits
llm_findings.json→ setsuser_verdicttoaccepted/rejected→codewalk_accept_and_verify_fixreturns the accepted findings → the host applies them and verifies withcodewalk_run_static_analysis+codewalk_run_tests - (Optional)
codewalk_re_review()→ fresh review that hides rejected findings
API review flow
curl -X POST http://localhost:8000/review \
-H "Content-Type: application/json" \
-d '{}'
Runs: static analysis → batch review (parallel LLM) → raw findings JSON (issues + static_issues + session_id).
Fix flow (Copilot-style diff review):
- Accept/reject findings in the UI
POST /review/preview-edits— generates the proposed diff per accepted finding (dry run, no writes)- Review the diffs, approve selected edits
POST /review/apply-edits— writes approved diffs, verifies with static analysis + tests, rolls back failures (a write is refused if the file changed since the preview)
✨ Features
| Feature | Description |
|---|---|
| 🔍 Module Detection | Auto-groups files into packages/modules by directory structure |
| 🕸️ Dependency Graph | Parses imports across 15+ languages via tree-sitter |
| 💥 Blast Radius | BFS on reversed dependency graph → shows transitive impact of any change |
| 📖 Reading Order | Topological sort → "read config.py before embedder.py because embedder imports config" |
| 🔄 Execution Flow | Entry points, module/file dependency chains, D3/ELK diagrams |
| 🤖 AI Chat | LangGraph agent with 7 tools, multi-turn conversation with memory |
| 🔎 Semantic Search | ChromaDB vector search on embedded code chunks (RAG) |
| 🔬 Code Review | Context-enriched review pipeline: test coverage, blast radius, guidelines RAG, deep analysis |
| 🔄 Incremental Reindex | Content hash comparison — only re-embeds changed files, skips unchanged |
| 🧩 MCP Server | 43 MCP tools for VS Code Copilot / Claude Code / Cursor / Codex |
| 🎙️ Voice Interface | Talk to your codebase — mic recording, local STT (faster-whisper), agent-driven routing (MCP + API), TTS response |
| 🔬 Graph Intelligence | DuckDB persistent graph + igraph C-speed traversal: cycle detection, centrality, import chain tracing |
| 🧬 Corrective RAG | Distance-based chunk filtering (free) + LLM answer grading + query rewriting for reliable answers |
| 📦 Parent-Child Chunking | Full functions stored as parents, sub-chunks searched — retrieve complete context on match |
| ⚡ Parallel Embedding | Producer-consumer pipeline — CPU chunking overlaps with GPU embedding |
| 🏗️ Multi-Provider LLM | Ollama (local), OpenAI, Anthropic, Groq, Gemini, OpenRouter, DeepSeek |
| 📚 Doc Indexing | Index team docs (.md, .pdf, .txt) — search and ask questions with source citations |
| 🔄 Reflection | Actor→Critic→Improve loop used by deep research to refine cross-cutting reports |
| 🧑💻 Human-in-the-Loop | Approval gate before any code/file modification — LangGraph checkpoint + interrupt |
| 🔬 Deep Research | Fan-out parallel search → merge → synthesize → reflect for complex cross-cutting questions |
| 🏗️ Architecture Health | Graph stats, bottleneck files (betweenness centrality), PageRank, cycle detection with fix suggestions |
| 🌐 15+ Languages | Python, JS, TS, Java, Go, Rust, Ruby, PHP, C#, C++, C, Dart, Kotlin, Swift, YAML |
Supported Languages
| Language | Extensions | Tree-sitter Parsing | Import Extraction |
|---|---|---|---|
| Python | .py |
✅ | ✅ |
| JavaScript | .js, .jsx |
✅ | ✅ |
| TypeScript | .ts, .tsx |
✅ | ✅ |
| Java | .java |
✅ | ✅ |
| Go | .go |
✅ | ✅ |
| Rust | .rs |
✅ | ✅ |
| Ruby | .rb |
✅ | ✅ |
| PHP | .php |
✅ | ✅ |
| C# | .cs |
✅ | ✅ |
| C++ | .cpp |
✅ | ✅ |
| C | .c |
✅ | ✅ |
| Kotlin | .kt |
✅ | ✅ |
| Swift | .swift |
✅ | ✅ |
| Dart | .dart |
✅ (optional install) | ✅ |
| YAML | .yaml, .yml |
— | — |
| JSON | .json |
— | — |
| TOML | .toml |
— | — |
| Markdown | .md |
— | — |
Tree-sitter parsing = extracts functions, classes, and methods for accurate chunking and function explanations.
Import extraction = builds the dependency graph, blast radius, and reading order.
Languages without tree-sitter support still get indexed via text splitting — they work with semantic search and AI chat, just without function-level granularity.
🆚 Codewalk vs. alternatives
Codewalk is not another AI autocomplete. It is a codebase intelligence layer: it builds a persistent dependency graph, embeds your code, indexes your docs, and exposes that intelligence through a UI, an MCP server, and an API.
If you need deep cross-file reasoning, blast-radius analysis, or AI review inside your existing IDE agent, Codewalk fits where general-purpose assistants stop.
| Use case | Typical approach | What Codewalk does differently |
|---|---|---|
| Explain this codebase | Ask a generic chat model and paste files | Builds a live graph + RAG so answers are grounded and cite real files |
| PR review | Lint + human review | LLM review with blast-radius, architecture, and custom guidelines |
| Refactor shared code | Grep for imports | Dependency graph + blast radius showing transitive impact |
| Onboard a new developer | Read wiki pages | Reading order + module map generated from actual code |
| Team knowledge | Search Confluence/Notion | Index docs alongside code and ask with citations |
| AI agent tooling | Write custom scripts or prompts | 43 MCP tools the agent can call directly |
🎬 Demo
Knowledge Graph UI
https://github.com/user-attachments/assets/48d30d70-2f4b-46e9-b4ca-0feb1341e503
Run Frontend from Any Repo
https://github.com/user-attachments/assets/ab140781-0e2f-432e-bc14-939eb82112d3
MCP — Analyze Codebase
https://github.com/user-attachments/assets/a85ec23b-eba6-4ff2-9c49-553fda4ab8bc
MCP — Overview
https://github.com/user-attachments/assets/d65d23c6-38bc-4610-b5d0-62669d85e5fd
MCP — Search Codebase
https://github.com/user-attachments/assets/23244594-42b5-4a39-9f30-d2e2ff10454f
MCP — Explain Function
https://github.com/user-attachments/assets/252a4738-3a22-4759-94f3-0ac41f7f0c09
MCP — Blast Radius
https://github.com/user-attachments/assets/052fa64b-e421-48ed-b65c-29609e0caf32
MCP — Run Review
https://github.com/user-attachments/assets/de36cdff-610b-4f4b-a422-7cff737fef2f
MCP — Ask Docs
https://github.com/user-attachments/assets/2b143e1c-f485-43b0-a750-aec0da627ea1
API — Overview
https://github.com/user-attachments/assets/f3ecaf4f-b0f0-4840-922e-806e840e3daf
API — Modules & Module Details
https://github.com/user-attachments/assets/b145f967-137b-43fc-873a-565c600dbb6b
API — Reading Order
https://github.com/user-attachments/assets/31f36fe9-67ea-46bc-a2b8-e64b982145d5
API — Code Review
https://github.com/user-attachments/assets/321870f0-2a12-4b48-8ed2-f5956ee3ad2e
API — Architecture
https://github.com/user-attachments/assets/1246efec-c52c-4b7d-bb63-c5eb72607fd2
API — Blast Radius
https://github.com/user-attachments/assets/e7aba067-e497-4a00-83a1-6d53f473d555
API — Team Docs Ask
https://github.com/user-attachments/assets/1b2c88cb-5eab-4b7c-8487-42ae737ad90e
🖥️ Frontend — Knowledge Graph UI
Codewalk ships with a Next.js frontend for visual codebase exploration.
What you can do
- Structural view — explore the repo as a layered dependency graph: modules, files, classes, and functions laid out as an interactive path flow.
- Knowledge view — semantic graph of entities and relationships surfaced by the AI analysis.
- Path Finder — pick a source and target node and discover import/dependency paths between them.
- Search — fuzzy + semantic search across files, symbols, and concepts.
- Blast Radius / Diff mode — visually highlight changed and affected nodes.
- Themes — switch between presets (Dark Gold, Dark Ocean, Dark Forest, Dark Rose, Light Minimal), accent colors, and heading fonts; your choice is saved locally.
- Info Panel — unified node details, metrics, source preview, and project overview.
- KineticShell navigation — index-dependent tabs stay locked until
GET /index-statusreportsindexed: true. - Cloud Admin — visit
/adminto register repos, list repos, trigger indexing, copy tokens, and check server health/version.
Run it
Quick start from a target repo
If you already have the Codewalk repo cloned elsewhere, run the combined launcher from the repo you want to explore:
/path/to/codewalk/scripts/run-ui-for-repo.sh
This starts the API from your current directory (discovering codewalk.yaml) and the frontend from the Codewalk checkout, automatically setting CODEWALK_REPO_PATH so the UI reads .codewalk/ from your repo.
Frontend-only development
cd frontend
npm install
npm run dev
If you change frontend code and see stale chunk 404s or client-side exceptions, restart with a clean build cache:
npm run dev:clean # clears .next and starts fresh
npm run restart # kills port 3000 and restarts dev
# or
./scripts/restart-frontend.sh
Set NEXT_PUBLIC_API_URL to point at the backend (e.g. http://localhost:8000 or https://api.codewalk.xyz).
Then open http://localhost:3000, analyze a repo, and click Knowledge Graph.
Demo
🎥 [Video coming soon — add frontend walkthrough here]
⚙️ Setup (local)
Production cloud server? See FULL_SETUP_GUIDE.md — step-by-step: Hetzner,
api.codewalk.xyz, GitHub App, webhooks, MCP download.
Prerequisites
| Tool | Version | Check |
|---|---|---|
| Python | 3.10+ | python3 --version |
| Node.js | 18+ | node --version |
| Git | Any | git --version |
| Ollama (optional) | Latest | ollama --version |
1. Clone the codewalk repo
git clone https://github.com/gupta29470/codewalk.git
cd codewalk
2. Backend setup in codewalk
# Create virtual environment
python3 -m venv .codewalk-env
source .codewalk-env/bin/activate # macOS / Linux
# .codewalk-env\Scripts\activate # Windows
# Install Python dependencies
pip install -r requirements.txt
If you're behind a VPN, corporate proxy, or private network, package installations and model downloads may fail due to blocked connections or SSL certificate errors.
Recommended: Use a normal (non-VPN) network for first-time setup.
Codewalk's setup downloads packages from PyPI, npm, and HuggingFace. These are one-time downloads — once installed, everything runs locally. If possible:
- Disconnect from VPN temporarily
- Run the setup steps (
pip install,npm install, start the backend once to download the embedding model) - Reconnect to VPN — everything is cached locally, no more downloads needed
After the first run, Codewalk works fully offline (with Ollama). The VPN/corporate network won't cause any issues.
# If you get an SSH error, run this first:
git config --global url."https://github.com/".insteadOf "git@github.com:"
# Then install:
pip install "tree-sitter-dart @ git+https://github.com/UserNobody14/tree-sitter-dart.git"
Without this, Codewalk still works — Dart files just won't get tree-sitter parsing (falls back to text splitting).
3. Frontend setup in codewalk
cd frontend
npm install
cd ..
4. Configure environment in codewalk
Copy the template: cp env.local.example.txt .env then edit:
# ─── LLM Configuration ──────────────────────────────────────
# Provider: ollama | openai | anthropic | gemini | groq | openrouter
LLM_PROVIDER=ollama
LLM_MODEL=qwen2.5-coder:7b
# ─── Embeddings ──────────────────────────────────────────────
EMBEDDING_MODEL=jinaai/jina-code-embeddings-1.5b
# ─── API Keys (only fill the one you're using) ──────────────
# GROQ_API_KEY=gsk_...
# OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...
# GOOGLE_API_KEY=AI...
# OPENROUTER_API_KEY=sk-or-...
5. Pull an Ollama model (if using local LLM)
ollama pull qwen2.5-coder:7b
| Model | Size | Tool Calling | Best For |
|---|---|---|---|
qwen2.5-coder:7b |
4.7 GB | ✅ | Code-focused, fast |
qwen3.5:latest (8B) |
6.6 GB | ✅ | General + code |
qwen3.5:27b |
17 GB | ✅ | Best accuracy |
🚀 Usage
Option 1: Web UI
Quick launch from a target repo (recommended for exploration):
From the repo you want to explore, run the combined launcher in the Codewalk checkout:
/path/to/codewalk/scripts/run-ui-for-repo.sh
It kills any process on ports 8000/3000, starts the API from the target repo, starts the frontend from the Codewalk checkout, and sets CODEWALK_REPO_PATH automatically. Then open http://localhost:3000.
Manual two-terminal setup (for frontend/backend development):
Open two terminals in codewalk:
Terminal 1 — Backend API
source .codewalk-env/bin/activate
uvicorn src.codewalk.api.main:app --reload --port 8000
Terminal 2 — Frontend
cd frontend
npm run dev
If the frontend throws stale chunk 404s after pulling or editing code, restart it cleanly:
npm run dev:clean
# or from the project root
./scripts/restart-frontend.sh
Open http://localhost:3000 → click Analyze Codebase (the repo is discovered from the working directory via codewalk.yaml).
Then explore:
- Knowledge Graph — interactive structural + knowledge graph, layer/module legend, node-category filters, detail-level toggle, persona selector, Path Finder, export menu, code viewer, file explorer, tour/onboarding, mobile layout, edge styling, and diff overlay
- Overview — tech stack, modules, dependency diagram, riskiest files
- Modules — browse all modules, click one for file list + dependencies
- Blast Radius — which files break if you change each file
- Reading Order — optimal file reading sequence with risk levels
- Execution Flow — D3/ELK diagram of module/file dependencies
- Chat — ask any question ("explain the authentication flow", "what does scanner.py do?")
- Code Review — review git diffs, review single files, load team guidelines
- Voice — click the mic, ask a question by speaking, hear the answer read aloud
- Smart Reindex — incremental re-embed with stats (skipped, changed, deleted)
- Research — deep cross-cutting reports with a structured architecture diagram card
- Cloud Admin —
/adminpage for repo registration, token management, and server health
Option 2: MCP Server (VS Code Copilot / Claude Code / Cursor)
See MCP Integration below.
Option 3: REST API
# Start the backend
source .codewalk-env/bin/activate
uvicorn src.codewalk.api.main:app --reload --port 8000
Step 1 — Analyze a codebase:
# Run from inside the repo you want to analyze (repo is discovered from cwd via codewalk.yaml)
curl -X POST http://localhost:8000/analyze \
-H "Content-Type: application/json" \
-d '{"index_mode": "auto"}'
Step 2 — Check index status and explore the results:
# Check whether the current workspace is indexed
# Optional: ?repo_path=/path/to/repo (defaults to cwd discovery)
curl "http://localhost:8000/index-status" | python3 -m json.tool
# Project overview (tech stack, modules, riskiest files)
curl http://localhost:8000/overview | python3 -m json.tool
# List all modules
curl http://localhost:8000/modules | python3 -m json.tool
# Dive into a specific module
curl http://localhost:8000/modules/auth | python3 -m json.tool
# What breaks if I change files in the auth module?
curl http://localhost:8000/blast-radius/auth | python3 -m json.tool
# Optimal reading order
curl http://localhost:8000/reading-order | python3 -m json.tool
# Execution flow (entry points, dependency chains)
curl http://localhost:8000/execution-flow | python3 -m json.tool
Step 3 — Chat with the agent:
# Ask a question
curl -X POST http://localhost:8000/chat \
-H "Content-Type: application/json" \
-d '{"message": "Explain this project", "thread_id": "thread-1"}'
# Follow-up (same thread_id = conversation memory)
curl -X POST http://localhost:8000/chat \
-H "Content-Type: application/json" \
-d '{"message": "What does the auth module do?", "thread_id": "thread-1"}'
# After code changes — refresh analysis without re-embedding
curl -X POST http://localhost:8000/refresh
# Incremental reindex — only re-embed changed files
curl -X POST http://localhost:8000/incremental-reindex
Codewalk MCP questions
What tools does Codewalk MCP provide?
It exposes 8 tools, including codewalk_analyze_codebase, codewalk_generate_config, codewalk_find_circular_dependencies, codewalk_get_architecture_health, codewalk_get_review_details.
How does Codewalk handle large codebases without high token costs?
It uses RAG to embed code into a vector database, retrieving only the relevant chunks for a query rather than sending the entire codebase to the LLM.
Can I use Codewalk for automated PR reviews?
Yes, it features a context-enriched review pipeline that uses dependency graphs and blast radius analysis to identify risky changes and security issues.
Does it support voice commands?
Yes, it includes a voice interface that allows you to talk to your codebase via microphone and hear answers read aloud.