CodeMeridian MCP server
2026년 11월 14일 커밋Provides a local graph memory layer for AI coding agents by indexing codebases into Neo4j to provide precise architectural context.
다른 이름 Driftya/code-meridian
- 스타
- 5
- Tools
- 41
- 다운로드, 30일
- —
- 최신 버전
- —
- 마지막 커밋
- 2026년 11월 14일
- 라이선스
- MIT
CodeMeridian MCP란?
CodeMeridian은(는) MCP server입니다. Provides a local graph memory layer for AI coding agents by indexing codebases into Neo4j to provide precise architectural context. 41개 도구를 제공합니다. 예: query_codebase, get_architectural_overview, get_context_for_editing.
프로젝트 README에서 생성된 요약
CodeMeridian MCP server 정보
Providing a local graph memory layer for AI coding agents is what CodeMeridian enables by indexing codebases into Neo4j. This tool creates a deterministic context layer that allows developers to give AI assistants precise architectural information instead of relying on file-based guessing. It works with MCP-compatible clients like Claude Code, GitHub Copilot, Cline, and Continue.dev to provide persistent knowledge that survives editor restarts.
Users run the server locally using the CodeMeridian.Indexer CLI and a Neo4j instance. The system supports C#, TypeScript, JavaScript, HTML, CSS, and various configuration files. While core functionality requires no LLM API key, users can opt-in to semantic features using local Ollama or cloud providers for embeddings. The server provides specific tools like find_impact to identify the blast radius of changes and build_minimal_context to estimate token costs and suggest appropriate model sizes.
활용 사례
- 1Identify testing gapsRequest a list of methods within the codebase that currently lack test coverage.
- 2Optimize context usageInstruct the AI to generate a small, efficient context pack to save tokens before performing an edit.
- 3Detect architectural violationsUse the indexed architecture templates to find where the code deviates from established patterns.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
CodeMeridian MCP 도구 41
README에서 감지됨query_codebaseget_architectural_overviewget_context_for_editingbuild_minimal_contextfind_impactfind_connectionfind_unreferencedfind_coverage_gapsfind_test_shieldfind_similar_nodeshybrid_searchfind_implementation_patterns
| query_codebase | — | |
| get_architectural_overview | — | |
| get_context_for_editing | — | |
| build_minimal_context | — | |
| find_impact | — | |
| find_connection | — | |
| find_unreferenced | — | |
| find_coverage_gaps | — | |
| find_test_shield | — | |
| find_similar_nodes | — | |
| hybrid_search | — | |
| find_implementation_patterns | — |
도구 41개 모두 보기도구 수 줄이기
find_duplicate_candidatesfind_frontend_cascade_conflictsfind_config_definitionsfind_config_usagesearch_documentationfind_tool_dependency_impactrebuild_keyword_graphclassify_keywordsfind_related_knowledgefind_implementation_surfaceanalyze_feature_implementation_pathanalyze_changed_subgraphplan_context_workflowexecute_context_workflowreplace_surfacesuggest_extractionscheck_graph_freshnessfind_graph_driftfind_smell_pathsfind_stale_knowledgeknowledge_decayrecord_change_contextget_change_contextstart_change_context_challengeanswer_change_context_challengerecord_change_context_challenge_noteresolve_exact_symbolclear_project_knowledgeclear_code_graph
| find_duplicate_candidates | — | |
| find_frontend_cascade_conflicts | — | |
| find_config_definitions | — | |
| find_config_usage | — | |
| search_documentation | — | |
| find_tool_dependency_impact | — | |
| rebuild_keyword_graph | — | |
| classify_keywords | — | |
| find_related_knowledge | — | |
| find_implementation_surface | — | |
| analyze_feature_implementation_path | — | |
| analyze_changed_subgraph | — | |
| plan_context_workflow | — | |
| execute_context_workflow | — | |
| replace_surface | — | |
| suggest_extractions | — | |
| check_graph_freshness | — | |
| find_graph_drift | — | |
| find_smell_paths | — | |
| find_stale_knowledge | — | |
| knowledge_decay | — | |
| record_change_context | — | |
| get_change_context | — | |
| start_change_context_challenge | — | |
| answer_change_context_challenge | — | |
| record_change_context_challenge_note | — | |
| resolve_exact_symbol | — | |
| clear_project_knowledge | — | |
| clear_code_graph | — |
자동 검사
2026년 11월 15일에 실행됨전체 보고서 →아직 인증되지 않았습니다. 서버는 80점 이상의 점수, 심각한 결함 없음, 그리고 검사에 충분한 데이터를 갖추어야 합니다. 검사 방식 · 점수를 높이기 위해 수정할 항목
- 소스 저장소 연결 및 접근 가능driftya/code-meridian is public and reachablegithub.com/driftya/code-meridian ↗통과
- 패키지가 이 저장소를 소스로 명시검사되지 않음
- 빌드 출처(Sigstore 증명)검사되지 않음
- 오픈 소스 라이선스 (OSI)MITspdx.org/licenses/MIT.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-14github.com/driftya/code-meridian ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음검사되지 않음
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
- 모델에 대한 숨겨진 지침 없음41 tool descriptions and the README read; no override phrases, credential paths or hidden characters통과
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기CodeMeridian
CodeMeridian is a local graph memory layer for AI coding agents.
It indexes your codebase into Neo4j and exposes that structure through MCP, so AI coding tools can ask precise questions before editing instead of guessing from open files. It works with MCP-compatible clients such as GitHub Copilot, Claude Code, Continue.dev, Codex-style agents, Cline, and local agent workflows.
It is built to be the deterministic context layer for large codebases: callers, dependencies, tests, documentation, hotspots, dead code, diagnostics, and cross-project relationships stay available across sessions.
CodeMeridian can also derive a keyword graph on top of indexed code and documentation. That adds an explainable lexical layer for finding related docs, diagnostics, endpoints, and symbols when there is no direct structural edge.
This is especially useful for local or smaller coding models, where every token matters. CodeMeridian does not try to replace the model. It makes the model’s job smaller by giving it the smallest useful slice of architecture before it writes code.
Core usage requires no LLM API key. Optional semantic features can use local Ollama or a cloud embedding provider. The assistant is the AI; CodeMeridian is the knowledge engine.
Why CodeMeridian?
Copilot can still read files beyond what is already open, but it has to spend context to discover them and the relationships do not persist. CodeMeridian makes that discovery explicit, cheaper, and reusable.
The graph is yours. CodeMeridian stores indexed code structure, documentation, diagnostics, and remembered project knowledge in your Neo4j instance. Nothing is sent to a CodeMeridian cloud service. If you use Copilot, Codex, Claude Code, or another hosted assistant, that assistant still has its own data handling rules, but the CodeMeridian knowledge graph itself stays under your control.
| Without CodeMeridian | With CodeMeridian |
|---|---|
| The assistant loads files ad hoc as it searches for context | The assistant queries a graph of your entire codebase |
| Context disappears between sessions | Knowledge persists locally in Neo4j |
| "What calls this method?" requires manual searching | find_impact answers from the call graph |
| Refactors can miss hidden callers | Blast radius is known before edits |
| Dead code and test gaps stay invisible | find_unreferenced and find_coverage_gaps surface them |
| Large context windows get filled with noise | The agent gets the smallest useful architecture slice |
| Small local models struggle with broad repository context | Graph-backed context makes the task smaller |
| Assistants guess which model/context size is enough | Context packs include token estimates and model guidance |
| Stale indexes quietly mislead agents | Freshness and drift checks say when to re-index |
| Docs and decisions live outside the code graph | Knowledge, docs, diagnostics, and code links can be queried together |
What this gives you in practice:
- Local ownership: the graph and knowledge store run in your Neo4j, not a hosted CodeMeridian service.
- Persistent memory: architecture, docs, diagnostics, external concepts, and agent notes survive editor restarts.
- Lower context waste: tools return callers, callees, tests, likely files, and small snippets instead of whole-file dumps.
- Safer edits: impact, downstream dependencies, diagnostics, drift, and missing tests are visible before implementation.
- Model-aware context:
build_minimal_contextestimates token cost and suggests when a small model is enough. - Explainable results: exact, heuristic, stale, and file-only matches are labeled so the assistant can say what it trusted.
Built for agent-first workflows
AI coding agents are powerful, but they often work from incomplete or temporary context. They may search files repeatedly, miss hidden callers, forget previous discoveries, or fill their context window with noisy whole-file dumps.
CodeMeridian gives those agents a persistent graph-backed map of the repository. Instead of asking the model to rediscover the codebase every session, the agent can query CodeMeridian for the specific architecture slice it needs.
Typical workflow:
- Start CodeMeridian locally.
- Index your repository.
- Connect an MCP-compatible coding agent.
- Ask the agent to build a minimal context pack before editing.
- Let the agent use impact, freshness, documentation, and test-coverage checks while it works.
Example prompt:
Use CodeMeridian to build a minimal context pack for the authentication flow before changing login behavior.
Why this helps smaller local models
Small local coding models are most useful when the context is precise. CodeMeridian helps by turning a repository into a graph-backed memory layer, so agents can retrieve the smallest useful context instead of scanning the whole codebase.
This is useful for 7B-class models, low-memory machines, and local-first workflows where context size, privacy, and repeatable code understanding matter.
Without CodeMeridian, the model may need to infer architecture from file names and ad hoc searches. With CodeMeridian, the agent can ask targeted questions:
What calls this method?
Which tests cover this service?
Which frontend components use this endpoint?
Which stylesheet selectors target this class?
What docs mention this symbol?
Is the graph fresh enough to trust?
What is the smallest context needed for this edit?
CodeMeridian does not make a small model magically perfect. It reduces the amount of guessing the model has to do.
CI now publishes a GitHub Actions coverage summary plus separate .NET and TypeScript line-coverage badges from the default branch.
What It Indexes
CodeMeridian currently supports:
- C# via a Roslyn indexer
- TypeScript / JavaScript / TSX / JSX via a shared ts-morph indexer
- HTML, CSS, and SCSS via a static frontend relationship indexer
- README and documentation files
- Configuration files such as
.env,.env.local,appsettings.json,appsettings.*.json,app.config,web.config,NuGet.config,host.json,local.settings.json,global.json,launchSettings.json,package.json,tsconfig.json,jsconfig.json,vite.config.ts,eslint.config.js,function.json,meridian.json, and Docker Compose YAML - Optional vector embeddings for semantic code similarity (find duplicate patterns, refactoring opportunities)
The frontend support is intentionally bounded and static: CodeMeridian can index markup, selectors, stylesheet imports, CSS variables, and some explainable selector/cascade metadata, but it does not try to emulate the full browser runtime.
The indexer is designed as a language-agnostic pipeline: future language indexers can write into the same graph model and be queried through the same MCP tools. Embeddings are opt-in (disabled by default) and are now generated by the CodeMeridian backend, which can use local Ollama (free) or OpenAI (paid).
Quick Start
Prerequisites:
- Docker Desktop
- .NET 10 SDK
- GitHub Copilot in VS Code
- Node.js 18+ when indexing TypeScript / JavaScript / TSX / JSX or HTML/CSS/SCSS frontend files
Install the CLI:
dotnet tool install -g CodeMeridian.Indexer
Start CodeMeridian:
codemeridian serve
codemeridian init
Index this repository:
codemeridian index . --clear
If you are running from a source checkout before installing the global tool:
Copy-Item .env.sample .env
docker compose up -d
dotnet run --project tools/Indexer -- . --clear
dotnet run --project tools/Indexer -- config rebuild --project CodeMeridian
dotnet run --project tools/Indexer -- index . --skip-keywords
dotnet run --project tools/Indexer -- keywords rebuild --project CodeMeridian
To create a local project config and MCP client config, run:
codemeridian init .
Run codemeridian init . again later to refresh an existing meridian.json. Missing defaults are merged in, the config version is bumped, and your existing project-specific values are preserved.
codemeridian init . also seeds .meridian/architecture.json if it does not exist, copies bundled templates from the package architectures/ folder into .meridian/architectures/, and copies agent guidance into meridian-agent-capabilities/ so repository docs stay user-owned. The bundled templates include architecture.clean.template.json, architecture.onion.template.json, architecture.hexagonal.template.json, architecture.layered.template.json, and architecture.vertical-slice.template.json. The active architecture file is referenced from meridian.json at architecture.path and drives find_architecture_violations and find_smell_paths after indexing.
Open this folder in VS Code or any MCP-capable client. The MCP server is registered through .vscode/mcp.json, and MCP-compatible clients can call CodeMeridian tools while you chat.
Common Questions
Ask Copilot things like:
Use CodeMeridian to give me an architectural overview.
Before changing OrderService.PlaceOrderAsync, what calls it?
Which methods have no test coverage?
Build a minimal context pack before I change OrderService.PlaceOrderAsync.
How is this TypeScript component connected to the backend?
Which Newtonsoft.Json usages are safe to replace with System.Text.Json first?
What tightly connected groups look like good extraction candidates in payments?
Usage
See usage.md for copy-paste prompts that help AI coding assistants use CodeMeridian safely before editing.
Core Tools
| Tool | What it does |
|---|---|
query_codebase |
Natural-language search over code structure |
get_architectural_overview |
Project map by namespace/module |
get_context_for_editing |
Compact callers/callees/interfaces context for a node |
build_minimal_context |
Bounded context pack with callers, callees, impact, tests, gaps, likely files, token estimate, and model guidance |
find_impact |
Backward blast-radius analysis |
find_connection |
Shortest path between two code elements |
find_unreferenced |
Dead-code candidates |
find_coverage_gaps |
Production code not called by tests |
find_test_shield |
Map direct test protection, indirect shields, and unshielded change-path nodes |
find_similar_nodes |
Find duplicate code patterns (requires embeddings enabled) |
hybrid_search |
Find semantically similar code near a node or subsystem boundary |
find_implementation_patterns |
Find reusable implementation shapes such as entry -> service -> repository -> tests |
find_duplicate_candidates |
Review likely duplicate methods/classes with refactor-risk signals |
find_frontend_cascade_conflicts |
Report likely CSS/SCSS override conflicts from indexed specificity and source-order metadata |
find_config_definitions |
Find where a canonical config key is defined or overridden |
find_config_usage |
Find which code reads or binds a canonical config key |
search_documentation |
Search indexed README/ADR/documentation content |
find_tool_dependency_impact |
Show which CodeMeridian tools, reports, evaluators, docs, and regression suites depend on a tool or shared contract |
rebuild_keyword_graph |
Rebuild derived Keyword nodes and HAS_KEYWORD edges from indexed graph text |
classify_keywords |
Classify derived keywords as domain/technical/tooling/common/noise and persist usefulness scores |
find_related_knowledge |
Find lexically related code and docs through shared keywords |
find_implementation_surface |
Rank likely files and symbols to edit for a feature goal |
analyze_feature_implementation_path |
Map a feature request or docs/features file to implementation status, touched areas, tests, docs, missing graph evidence, and risk |
analyze_changed_subgraph |
Summarize changed-file risk, impacted nodes, tests, architecture smells, and docs from a bounded graph neighborhood |
plan_context_workflow |
Plan the right sequence of CodeMeridian tools for an agent task |
execute_context_workflow |
Execute an approved read-only context workflow and return per-step results |
replace_surface |
Group dependency replacement work into safe and risky clusters before a library migration |
suggest_extractions |
Rank tightly connected groups that look like good extraction candidates |
check_graph_freshness |
Report graph confidence from indexed file, line, and timestamp metadata |
find_graph_drift |
Detect stale graph data before relying on exact implementation targets |
find_smell_paths |
Show shortest forbidden architectural dependency paths |
find_stale_knowledge |
Detect stale docs, weak mentions, orphaned external concepts, and orphaned code references |
knowledge_decay |
Alias of find_stale_knowledge for graph-native stale-knowledge review |
record_change_context |
Preserve one bounded attributed human-cognitive-seed decision or constraint against an exact code node |
get_change_context |
Retrieve opt-in human-cognitive-seed context with current hash/orphan status |
start_change_context_challenge |
Open an MCP App with 3-4 LLM-authored code choices grounded in an exact node and its change context |
answer_change_context_challenge |
Validate the user's one or two selected answers, halt on mistakes, explain them, and allow retry |
record_change_context_challenge_note |
Save an optional user-written note after the challenge is solved |
resolve_exact_symbol |
Resolve symbol/file/line hints to canonical node IDs before editing |
clear_project_knowledge |
Clear one project's indexed graph and docs before rebuilding |
clear_code_graph |
Clear all indexed code graph nodes while preserving docs |
Architecture rules come from the indexed project configuration when .meridian/architecture.json is present and indexed. If no project-specific architecture has been indexed yet, CodeMeridian falls back to the default clean-architecture template.
Documentation
- Installation
- How CodeMeridian works
- Usage
- Context workflows
- Change context user guide
- Indexing projects
- Evaluating session usefulness
- Feature reference
- MCP 2 capabilities and operational limits
- Code embeddings and semantic search
- Publishing the indexer tool
- Ubuntu headless deployment
- Contributor and agent guide
- Detailed agent docs
Keyword Enrichment
Keyword enrichment is configured in src/McpServer/appsettings.json under KeywordEnrichment.
Key options:
MinimumKeywordLength: default4AllowedShortTerms: default includesapi,mcp,cli,sdk,jwt,sql,ast,ef,tsAdditionalStopwords: array of project-specific terms to suppress without code changes
Typical workflow:
1. Index your code and docs normally.
2. The MCP server queues incremental keyword refresh as nodes and documents are ingested.
3. Use find_related_knowledge on a node ID when you want explainable lexical matches.
4. Run rebuild_keyword_graph or classify_keywords manually when you want a full repair or rule refresh.
CLI equivalents:
codemeridian config rebuild --project CodeMeridian
codemeridian keywords rebuild --project CodeMeridian
codemeridian keywords classify --project CodeMeridian
Configuration indexing runs as part of the normal codemeridian index flow. Use --skip-config when you only want code, docs, and diagnostics without the configuration graph. Direct config-usage extraction now works in both the Roslyn and TypeScript indexers for process.env, import.meta.env, and C# IConfiguration access patterns.
You can override which files count as configuration sources in meridian.json with configurationFiles, for example:
{
"configurationFiles": [".env", ".env.local", "appsettings.json", "appsettings.*.json", "app.config", "web.config", "NuGet.config", "host.json", "local.settings.json", "global.json", "launchSettings.json", "package.json", "tsconfig.json", "jsconfig.json", "vite.config.ts", "eslint.config.js", "function.json", "meridian.json", "docker-compose*.yaml"]
}
Keyword classification is configured under KeywordClassification. It can mark keywords as Noise, CommonProjectTerm, TechnicalConcept, ToolingConcept, ArchitectureConcept, DiagnosticConcept, DomainConcept, or Unknown.
Project Layout
src/
Core/ Domain models
Application/ Query services and orchestration
Infrastructure/ Neo4j graph and knowledge storage
McpServer/ MCP server and REST ingestion API
Sdk/ Client library for ingestion
tools/
Indexer/ Unified indexer CLI
RoslynIndexer/ C# Roslyn indexer
TsIndexer/ TypeScript / JavaScript / TSX / JSX indexer
HtmlCssIndexer/ HTML / CSS / SCSS frontend indexer
docs/
features.md
how-it-works.md
installation.md
indexing.md
publishing.md
Status
CodeMeridian is early but usable. It already indexes C#, TypeScript/JavaScript/TSX/JSX, and bounded HTML/CSS/SCSS frontend relationships, persists the graph in Neo4j, and exposes MCP tools for Copilot, Codex, and other compatible clients. The roadmap is tracked in TODO.md.
Contributing
See CONTRIBUTING.md for contribution guidelines, AI-assisted development expectations, and validation steps.
CodeMeridian MCP 질문
CodeMeridian MCP는 어떤 도구를 제공하나요?
41개 도구를 제공합니다. 예: query_codebase, get_architectural_overview, get_context_for_editing, build_minimal_context, find_impact.
Does CodeMeridian require an LLM API key?
Core usage does not require an LLM API key, though optional semantic features can use local Ollama or cloud providers.
Where is my code data stored?
The knowledge graph and indexed structure are stored locally in your own Neo4j instance, ensuring local ownership.