DawnMCP is a privacy-conscious MCP server that provides repository intelligence and agentic coding assistance using local inference (Ollama, ChromaDB).
Repository Analysis & Indexing: analyze, scan, summarize, explain architecture and projects, and index any local repository (structure, dependencies).
Semantic Code Search & Q&A: ask natural-language questions about indexed codebases with grounded, file-and-line-cited answers; locate features and perform impact analysis.
Knowledge Graph: build and query structural graphs of files, functions, classes, and dependencies.
Long-Term Memory: save, search, update, and delete memories for user preferences, project info, technical decisions, conversations, and events.
Agentic Task Planning & Execution: decompose tasks into phases, generate code, review code, and debug issues.
Document Management: add, search, list, and delete project docs for semantic retrieval.
Privacy-Conscious: all inference and embeddings run locally; code never leaves your environment.
MCP-Native: compatible with MCP clients (Claude, Cursor) and deployable via NitroCloud.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@DawnMCP Where is the retry logic defined and how is it invoked?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
DawnMCP is a deployed MCP (Model Context Protocol) server that gives AI coding assistants — Claude, Cursor, and any MCP-compatible client — deep, grounded understanding of a codebase. Model inference runs through a local, open-source stack (Ollama), so code isn't sent to third-party cloud AI APIs, even though the server itself is hosted and shareable via a live endpoint.
Built by Team Dawn of AI, SRMIST — Runner-Up, Agentic AI Hackathon 2026 (₹10L prize pool, organized by SRM School of Computing, Dept. of Computing Technologies, and NitroStack).
What it does: DawnMCP indexes a repository and answers natural-language questions with grounded, file-and-line-cited responses — not guesses. It maintains persistent semantic memory across sessions, so project context isn't lost between conversations, and its agents can plan tasks, review code, and help debug by reasoning over the actual indexed codebase.
Who it's for: Teams and researchers working with proprietary or unpublished code — students on unpublished research, companies with sensitive IP, or anyone who wants AI coding assistance without routing their code through a third-party cloud LLM.
What makes it work:
Model inference runs through a local Ollama instance (qwen2.5-coder for reasoning, nomic-embed-text for embeddings), with ChromaDB for vector storage — no code sent to external AI APIs for inference
Built on the open MCP standard, not a closed plugin system — works with any MCP-compatible client
Deployed on NitroCloud for a shareable, always-on endpoint
Related MCP server: LocalNest MCP
🚀 MCP endpoint: https://dawnmcp-6a6d98d3-dawn-of-ai-srmist.app.nitrocloud.ai
Point any MCP-compatible client at this endpoint to try it directly — no local setup required.
{
"mcpServers": {
"dawnmcp": {
"url": "https://dawnmcp-6a6d98d3-dawn-of-ai-srmist.app.nitrocloud.ai"
}
}
}Node.js 18+
An MCP-compatible client (Claude Desktop, Cursor, etc.)
git clone https://github.com/dawnmcp/DawnMCP-1.git
cd DawnMCP-1
npm install
cp .env.example .env
npm run start🔌 MCP-native — works with any MCP-compatible client
🛠️ Tools, resources & prompts — exposes structured capabilities to AI agents
🧠 Persistent memory — retains project context across sessions instead of starting fresh each time
🔐 Secure by design — secrets stay in environment variables, never in code
⚡ Deployed on Nitrostack/NitroCloud — reliable, hosted, and instantly shareable
MCP (Model Context Protocol) · Ollama (qwen2.5-coder, nomic-embed-text) · ChromaDB · TypeScript · NitroStack · NitroCloud
Built by Dawn of AI, SRM Institute of Science and Technology, KTR — during the Agentic AI Hackathon 2026.
MIT © 2026
Diagnose error logs, stack traces, or failing tests to identify root cause and recommended fix using the DebuggerAgent.
Inputs: log (required), context.
Generate production code or step-by-step implementation for a planned step using the ExecutorAgent.
Inputs: step (required), context.
Decompose a complex software engineering request into structured implementation phases using the PlannerAgent.
Inputs: task (required), context.
Perform a comprehensive code review auditing security, performance, quality, and best practices using the ReviewerAgent.
Inputs: code (required), context.
Store and index a project document, spec, or architecture guide for semantic retrieval.
Inputs: title (required), content (required), category, metadata.
Delete a stored document by its UUID.
Inputs: id (required).
List all stored project documents and specs.
Inputs: no named parameters.
Search stored project documentation by semantic similarity.
Inputs: query (required), limit, category.
Permanently delete a stored memory by its ID. Use the memory ID from a previous search result.
Inputs: id (required).
Save a piece of information to long-term memory. Use this to remember user preferences, project context, technical decisions, conversations, or important events for future reference.
Inputs: content (required), category (required), metadata.
Search stored memories by semantic similarity. Use this to recall past conversations, find previously stored project context, retrieve technical decisions, or look up user preferences.
Inputs: query (required), limit, category.
Update the content of an existing memory. The embedding is regenerated automatically. Use the memory ID from a previous search result.
Inputs: id (required), content (required), metadata.
Analyze a local repository to understand its structure, framework, dependencies, and architecture. Scans all files, performs AST parsing on source code, detects patterns, and generates an AI summary.
Inputs: path (required).
Ask a natural language question about an indexed codebase. Uses RAG (retrieval-augmented generation) over ChromaDB vector search and Qwen2.5-Coder LLM.
Inputs: question (required), maxChunks, repo_path.
Construct a structural knowledge graph of files, functions, classes, and dependencies for a repository.
Inputs: path (required).
Generate a detailed architectural explanation of a repository.
Inputs: path (required).
Generate a comprehensive project explanation including architecture, technology stack, and module structure.
Inputs: path (required).
Locate where a specific feature or capability is implemented in the codebase.
Inputs: path (required), feature (required).
Analyze potential impact of modifying a specific file or symbol across the codebase.
Inputs: file (required), path (required).
Index a local repository for semantic code search. Scans files, splits them into function/class chunks, generates embeddings using Ollama, and stores them in ChromaDB.
Inputs: path (required).
Query the repository knowledge graph by entity name or type (file, function, class, module, dependency).
Inputs: path (required), type, query.
Scan a local repository and list all files with classified types, languages, and aggregate statistics.
Inputs: path (required).
Get a concise high-level technical summary of the repository.
Inputs: path (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 23 tools
Most tools have clearly distinct purposes, but there are close overlaps among repo_explain_architecture, repo_explain_project, and repo_summarize_repository, as well as between repo_analyze_repository and repo_scan_files. Descriptions help, but an agent could confuse these similar-sounding tools.
Names follow a consistent category_verb_noun pattern with underscores (e.g., documents_add_document, memory_search_memory, repo_index_repository). Minor deviations exist in plural/singular forms (search_documents vs add_document) and semantically similar verbs like 'explain' versus 'summarize', but overall the pattern is predictable.
At 23 tools, the set is on the heavier side. The four domains each justify their existence, but the repo category has 11 tools, with several overlapping analysis/explanation options that could be consolidated. Still, it's within a workable range.
Documents and memory have near-complete CRUD coverage (missing document update), and repo tools cover scanning, indexing, analysis, and querying. Agent tools provide plan/execute/review/debug lifecycle. Minor gaps like no repository unindex or knowledge graph deletion, but core workflows are well covered.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Self-hosted AI workspace: semantic RAG document search, long-term memory, and AI chat via MCP.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
An MCP memory server. One memory your agents share — across models, devices and apps.
