Consult7 MCP Server: Codebase and Document Analysis

Overview

The Consult7 MCP Server is a lightweight service that enables high-context analysis of large codebases and document collections using modern large language models. It implements the Model Context Protocol (MCP) pattern to combine long-context model capabilities with retrieval-augmented workflows, letting you query, summarize, or analyze code and documentation across many files and repositories.

This server is especially useful when you need deep, cross-file insights (e.g., finding usages, understanding design intent, generating changelists) or when working with documentation sets that exceed standard model context windows. It connects to model providers such as OpenRouter, OpenAI, or Google AI and exposes a developer-friendly API for ingestion, retrieval, and question-answering over large corpora.

Features

• High-context analysis of codebases and document sets using retrieval-augmented generation
• Pluggable model backends: OpenRouter, OpenAI, Google AI (switchable via configuration)
• File and repo ingestion: chunking and embedding of large files for efficient retrieval
• Support for long-context models and RAG-style pipelines
• Configurable vector store and retrieval parameters (pluggable stores such as FAISS, SQLite-based stores, or external DBs)
• Simple HTTP API to submit analysis jobs, queries, and get structured responses
• Designed for integration into CI pipelines, developer tools, and code review workflows

Installation / Configuration

Prerequisites: Docker (recommended) or a Python/Node environment depending on the repository implementation. The examples below are generic and work with a build-from-source approach.

Clone and build:

git clone https://github.com/szeider/consult7.git
cd consult7
# Build a Docker image (if Dockerfile included in repo)
docker build -t consult7-mcp:latest .

Example Docker run with environment variables:

docker run -d --name consult7-mcp \
  -p 8080:8080 \
  -e MCP_PORT=8080 \
  -e MODEL_PROVIDER=openai \
  -e OPENAI_API_KEY=sk-XXXX \
  -e VECTOR_STORE=faiss \
  consult7-mcp:latest

Example environment variables (typical):

# Choose provider: openai | openrouter | google
MODEL_PROVIDER=openai

# OpenAI / OpenRouter / Google AI API keys
OPENAI_API_KEY=sk-...
OPENROUTER_API_KEY=or-...
GOOGLE_API_KEY=...

# Server runtime options
MCP_PORT=8080
CHUNK_SIZE=2000           # tokens or characters per chunk
EMBEDDING_MODEL=text-embedding-...
DOCUMENT_ROOT=/data/repos

# Vector store selection and parameters
VECTOR_STORE=faiss         # or sqlite, weaviate, etc.
VECTOR_DIM=1536

If the repo includes a docker-compose.yml, you can also run:

docker-compose up -d

Adjust CHUNK_SIZE and vector store settings to match the model and dataset size for best performance.

Available Tools / Resources

The MCP server typically exposes a set of composable tools and resources that you can use programmatically or via API:

• Document loaders: file system, Git repositories, ZIP uploads
• Chunker/segmenter: breaks large files into retrievable passages
• Embedding generator: uses chosen provider to create vector embeddings
• Vector store connectors: FAISS, SQLite-based persistent store, or remote vector DBs
• Retriever: configurable similarity search (top-k, hybrid scoring)
• RAG pipeline: template-driven prompts, context assembly, and model calls
• Diagnostic endpoints: ingestion status, index health, model provider diagnostics

These components are often pluggable so you can swap model backends and vector stores without changing client code.

Use Cases

1. Cross-file code reasoning

   • Scenario: You need to find all functions that call a deprecated logging API across a large monorepo and propose safe replacements.
   • How: Ingest repo, run a similarity search on chunks matching “deprecated logging API”, then use a long-context model to summarize change locations and produce a patch list.

   Example (illustrative API call):

   curl -X POST http://localhost:8080/analyze \
     -H "Content-Type: application/json" \
     -d '{
       "repo_path": "/data/repos/my-monorepo",
       "query": "Find calls to DeprecatedLogger.log and propose an alternative",
       "provider": "openai",
       "top_k": 10
     }'
   

2. Documentation summarization and onboarding

   • Scenario: Create a condensed onboarding guide from a large docs folder or design doc history.
   • How: Ingest documentation, retrieve highest-relevance passages for onboarding topics, then generate structured summaries and bullet lists.

3. Code review assistant

   • Scenario: During a pull request, provide focused context-aware suggestions that consider entire module history.
   • How: Ingest PR diff and repo snapshot, retrieve relevant context, and ask the model to generate review comments or identify risky changes.

4. Architecture and dependency analysis

   • Scenario: Understand cross-cutting dependencies and call graphs in a legacy codebase.
   • How: Use retrieval to assemble multi-file context and ask the model to outline module interactions and potential refactor targets.

Quick Tips

• Tune chunk size and overlap to balance recall vs. token usage.
• Use a dedicated embedding model and consistent vector store to maintain stable similarity results.
• Cache frequent queries and reuse embeddings when analyzing iterative changes.
• Monitor provider usage (tokens/cost) when working with large corpora; prefer smaller embedding models where appropriate.

This server is intended as a building block: integrate it into developer tools, CI pipelines, or internal platforms to provide deep, model-driven insights over large code and document collections.