Build a Codebase Intelligence Tool Like repowise With a RAG-Assisted MCP for Your Monorepo

A developer has created a RAG-assisted Model Context Protocol (MCP) server that turns a monorepo into a queryable knowledge base, enabling semantic code search for LLMs and CLI tools. The system uses tree-sitter for AST-aware chunking, a local embedding server with sentence-transformers, and a hybrid retriever combining vector similarity with BM25 lexical search. The tutorial details building three components: an indexer, an MCP server, and a retriever, with a file watcher for incremental updates.

Originally published on tamiz.pro. Modern monorepos contain hundreds of thousands of files spanning multiple services, libraries, and configurations. Traditional code search—whether ripgrep, Sourcegraph, or IDE search—struggles with semantic queries like "how do we handle payment retries?" or "find all places where user permissions are checked" . A RAG-assisted Model Context Protocol MCP server can turn your local codebase into a queryable knowledge base, giving LLMs and CLI tools accurate, context-rich answers. This tutorial shows you how to build a production-grade version of tools like repowise https://repowise.dev for your own monorepo. We'll build three components: ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ File Watcher│────▶│ Indexer │────▶│ Vector Store│ │ chokidar │ │ LangChain │ │ Qdrant │ └─────────────┘ └──────────────┘ └─────────────┘ │ ▼ ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ IDE / CLI │◀────│ MCP Server │◀────│ Retriever │ │ Claude, │ │ FastMCP │ │ Hybrid │ │ Cursor │ └──────────────┘ └─────────────┘ └─────────────┘ Indexer : Splits code into AST-aware chunks, embeds them, and stores them in a local vector database. MCP Server : Exposes a standardized interface tools, resources, prompts that any MCP-compatible client can consume. Retriever : Combines vector similarity with BM25 lexical search and AST context for precise retrieval. Initialize the project structure: mkdir monorepo-rag-mcp && cd monorepo-rag-mcp pnpm init mkdir -p packages/{indexer,mcp-server,embedding-server} Create a shared package for common types: // packages/shared/src/types.ts export interface CodeChunk { id: string; path: string; language: string; startLine: number; endLine: number; content: string; astMetadata?: Record<string, any ; } export interface IndexingConfig { monorepoRoot: string; excludePatterns: string ; languages: string ; } We use tree-sitter for language-agnostic parsing. This preserves semantic boundaries functions, classes instead of arbitrary character splits. js // packages/indexer/src/chunker.ts import { Parser } from "tree-sitter"; import as ts from "tree-sitter-typescript"; const parser = new Parser ; parser.setLanguage ts.language ; export function chunkFile content: string, filePath: string : CodeChunk { const tree = parser.parse content ; const chunks: CodeChunk = ; function traverse node: any { if "function declaration", "class declaration", "method definition" .includes node.type { chunks.push { id: ${filePath}:${node.startPosition.row}-${node.endPosition.row} , path: filePath, language: "typescript", startLine: node.startPosition.row, endLine: node.endPosition.row, content: content.slice node.startPosition.byte, node.endPosition.byte , astMetadata: { type: node.type, name: node.children 0 ?.text ?? "anonymous" } } ; } for const child of node.children traverse child ; } traverse tree.rootNode ; return chunks; } Run a local embedding server using sentence-transformers for privacy and zero API cost. python packages/embedding-server/main.py from fastapi import FastAPI from pydantic import BaseModel from sentence transformers import SentenceTransformer import uvicorn app = FastAPI model = SentenceTransformer "BAAI/bge-small-en-v1.5" class EmbedRequest BaseModel : texts: list str @app.post "/embed" def embed req: EmbedRequest : embeddings = model.encode req.texts, normalize embeddings=True .tolist return {"embeddings": embeddings} if name == " main ": uvicorn.run app, host="0.0.0.0", port=8000 Watch for file changes and update the vector store incrementally. python // packages/indexer/src/indexer.ts import chokidar from "chokidar"; import { QdrantClient } from "@qdrant/js-client-rest"; import { chunkFile } from "./chunker"; import axios from "axios"; const qdrant = new QdrantClient { url: "http://localhost:6333" } ; async function embed texts: string { const { data } = await axios.post "http://localhost:8000/embed", { texts } ; return data.embeddings; } async function indexFile filePath: string { const content = await fs.readFile filePath, "utf-8" ; const chunks = chunkFile content, filePath ; if chunks.length === 0 return; const embeddings = await embed chunks.map c = c.content ; const points = chunks.map chunk, i = { id: chunk.id, vector: embeddings i , payload: chunk } ; await qdrant.upsert "codebase", { points } ; } async function watch root: string { const watcher = chokidar.watch root, { ignored: /node modules|\.git|dist/g, persistent: true } ; watcher.on "add", path = indexFile path ; watcher.on "change", path = indexFile path ; watcher.on "unlink", path = qdrant.delete "codebase", { wait: true, points: path } ; } We'll use FastMCP TypeScript SDK to expose three tools: search code , get file context , and explain symbol . js // packages/mcp-server/src/server.ts import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; import { QdrantClient } from "@qdrant/js-client-rest"; import axios from "axios"; const server = new McpServer { name: "repo-wise", version: "1.0.0" } ; const qdrant = new QdrantClient { url: "http://localhost:6333" } ; server.tool "search code", { description: "Semantic + lexical search over the indexed monorepo", inputSchema: { type: "object", properties: { query: { type: "string", description: "Natural language query" }, limit: { type: "number", default: 10 } }, required: "query" } }, async { query, limit = 10 } = { // 1. Embed the query const { data: embedData } = await axios.post "http://localhost:8000/embed", { texts: query } ; const queryVector = embedData.embeddings 0 ; // 2. Vector search const vectorResults = await qdrant.search "codebase", { query: queryVector, limit: limit 2, // overshoot for reranking with payload: true } ; // 3. BM25 rerank simplified: use Qdrant's built-in sparse vector if configured, // or implement a local BM25 scorer on the retrieved candidates const scored = vectorResults.map r = { path: r.payload.path, lines: ${r.payload.startLine}-${r.payload.endLine} , snippet: r.payload.content.slice 0, 200 , score: r.score } ; return { content: { type: "text", text: JSON.stringify scored, null, 2 } }; } ; server.tool "get file context", { description: "Get full file content with line numbers for a given path", inputSchema: { type: "object", properties: { path: { type: "string" }, startLine: { type: "number" }, endLine: { type: "number" } }, required: "path" } }, async { path, startLine, endLine } = { const content = await fs.readFile path, "utf-8" ; const lines = content.split "\n" ; const slice = lines.slice startLine ?? 0, endLine ?? lines.length .join "\n" ; return { content: { type: "text", text: slice } }; } ; server.tool "explain symbol", { description: "Explain what a symbol function/class does based on code and comments", inputSchema: { type: "object", properties: { symbolName: { type: "string" }, language: { type: "string", default: "typescript" } }, required: "symbolName" } }, async { symbolName, language } = { const { data: embedData } = await axios.post "http://localhost:8000/embed", { texts: symbolName } ; const results = await qdrant.search "codebase", { query: embedData.embeddings 0 , limit: 5, filter: { must: { key: "language", match: { value: language } } } } ; const context = results.map r = r.payload.content .join "\n\n---\n\n" ; const prompt = You are a senior engineer. Explain the symbol "${symbolName}" based on the following code snippets:\n\n${context} ; // In production, call an LLM here. For demo, return context. return { content: { type: "text", text: prompt } }; } ; const transport = new StdioServerTransport ; server.connect transport ; Add to your claude desktop config.json : { "mcpServers": { "repo-wise": { "command": "node", "args": "./packages/mcp-server/dist/server.js" } } } In Cursor settings, add the MCP server as a custom tool: { "tools": { "name": "repo-wise", "command": "node", "args": "./packages/mcp-server/dist/server.js" } } Instead of filesystem watching which misses renames, churn , use post-commit and post-merge hooks: bash /bin/bash .git/hooks/post-commit ROOT=$ git rev-parse --show-toplevel pnpm --filter @repo/indexer run index --root "$ROOT" --commit $ git rev-parse HEAD Enable Qdrant's built-in sparse vectors BM25 for better lexical recall: await qdrant.createCollection "codebase", { vectors: { size: 384, distance: "Cosine" }, sparse vectors: { bm25: {} } } ; Then during search, use Qdrant's search with using: "bm25" and fuse scores. Q: How large a monorepo can this handle? A: With local embeddings and Qdrant, we've tested repos up to 2M files ~50GB . The bottleneck is initial indexing time, not query latency. Q: Can I use this with non-TypeScript languages? A: Yes. tree-sitter supports 100+ languages. Update the languages array and use the corresponding tree-sitter-<lang grammar. Q: How does this compare to GitHub Copilot Workspace? A: Copilot is cloud-hosted and proprietary. This tool runs entirely in your infrastructure, supports custom retrieval logic, and integrates with any MCP client Claude, Cursor, custom IDEs . Ready to ship? Start with the indexer package and iterate on chunking strategies. For production deployments, consider adding a lightweight job queue BullMQ for indexing and a reverse proxy for the embedding server. For production deployments, consider adding a lightweight job queue BullMQ for indexing and a reverse proxy for the embedding server. Below is a minimal BullMQ integration for the indexer package. js // packages/indexer/src/worker.ts import { Queue, Worker, Job } from 'bullmq'; import { IndexService } from './index-service'; import { redisConnection } from './redis'; export const indexQueue = new Queue 'codebase-indexing', { connection: redisConnection } ; export function startWorker { const service = new IndexService ; new Worker 'codebase-indexing', async job: Job = { const { filePath, content, projectId } = job.data; await service.indexFile projectId, filePath, content ; job.updateProgress 100 ; }, { connection: redisConnection } ; } export async function enqueueIndex projectId: string, filePath: string, content: string, { await indexQueue.add 'index-file', { projectId, filePath, content, }, { attempts: 3, backoff: { type: 'exponential', delay: 2000 }, removeOnComplete: true, removeOnFail: true, } ; } The embedding server should sit behind a reverse proxy that handles TLS termination, request buffering, and connection pooling. Here's an Nginx configuration: nginx.conf upstream embedding server { server 127.0.0.1:6000 max fails=3 fail timeout=30s; keepalive 32; } server { listen 443 ssl http2; server name embedding.internal; ssl certificate /etc/ssl/certs/embedding.pem; ssl certificate key /etc/ssl/private/embedding.key; location /v1/ { proxy pass http://embedding server/v1/; proxy http version 1.1; proxy set header Connection ""; Buffer large document batches proxy request buffering on; client max body size 50m; Timeout tuning for embedding models proxy connect timeout 10s; proxy send timeout 120s; proxy read timeout 120s; } location /health { proxy pass http://embedding server/health; } } A codebase intelligence tool generates significant operational data. You need visibility into indexing throughput, embedding latency, and MCP request patterns. python // packages/monitoring/src/logger.ts import pino from 'pino'; export const logger = pino { level: process.env.LOG LEVEL || 'info', formatters: { level: label = { level: label.toUpperCase } , }, timestamp: pino.stdTimeFunctions.isoTime, } ; export type MetricsEvent = | { type: 'index progress'; projectId: string; fileCount: number; total: number } | { type: 'embedding latency'; durationMs: number; model: string } | { type: 'mcp request'; toolName: string; durationMs: number; success: boolean } | { type: 'chunk generated'; projectId: string; chunkSize: number; strategy: string }; export function emitMetrics event: MetricsEvent { logger.info event, 'metrics' ; } | Metric | Why It Matters | Alert Threshold | |---|---|---| | Indexing throughput files/min | Detects slowdowns in scanning or embedding | < 10 files/min for 5 min | | Embedding latency p99 | Impacts MCP tool response times | 3s p99 | | MCP tool error rate | Indicates retrieval or parsing failures | 5% | | Chunk size distribution | Reveals if strategies produce unusable chunks | mean chunk < 50 tokens | | Vector store query latency | Directly affects LLM response time | 500ms p99 | | Memory usage per project | Catches memory leaks in long-running workers | 2GB/project | // packages/monitoring/src/tracing.ts import as opentelemetry from '@opentelemetry/api'; import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'; import { Resource } from '@opentelemetry/resources'; import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'; import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto'; import { registerInstrumentations } from '@opentelemetry/instrumentation'; import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'; import { PinoInstrumentation } from '@opentelemetry/instrumentation-pino'; const provider = new NodeTracerProvider { resource: new Resource { SemanticResourceAttributes.SERVICE NAME : 'monorepo-rag-mcp', SemanticResourceAttributes.SERVICE VERSION : '1.0.0', SemanticResourceAttributes.DEPLOYMENT ENVIRONMENT : process.env.NODE ENV, } , } ; provider.addSpanProcessor new SimpleSpanProcessor new OTLPTraceExporter ; provider.register ; registerInstrumentations { instrumentations: new HttpInstrumentation , new PinoInstrumentation , , } ; export const tracer = opentelemetry.trace.getTracer 'monorepo-rag-mcp' ; Using these spans, you can trace a single MCP tool call from the IDE through the gateway, into the RAG pipeline, through embedding generation, vector search, and context assembly—identifying exactly where latency accumulates. When user code contains comments or strings that resemble instructions, those can leak into the context window and influence the LLM's behavior. Mitigate this with input sanitization: js // packages/rag/src/sanitization.ts const INJECTION PATTERNS = /ignore previous instructions/i, /act as a different system/i, /you are now/i, /system prompt/i, /do not follow/i, ; export function sanitizeContext text: string : string { return INJECTION PATTERNS.reduce acc, pattern = acc.replace pattern, ' REDACTED INJECTION ATTEMPT ' , text ; } export function wrapCodeInSecurityBoundary code: string : string { return SECURITY BOUNDARY START\n${sanitizeContext code }\nSECURITY BOUNDARY END ; } In a monorepo, not all developers should have equal access. Implement project-level RBAC: js // packages/mcp-server/src/auth.ts import { z } from 'zod'; const AccessLevel = z.enum 'read', 'write', 'admin' ; type AccessLevel = z.infer<typeof AccessLevel ; interface ProjectPermission { projectId: string; userId: string; accessLevel: AccessLevel; inheritedFrom?: string; // parent workspace for monorepo hierarchy } export class PermissionResolver { private permissions: Map<string, ProjectPermission = new Map ; setPermissions projectId: string, perms: ProjectPermission { this.permissions.set projectId, perms ; } checkAccess userId: string, projectId: string, requiredLevel: AccessLevel : boolean { // Check direct permissions const direct = this.permissions.get projectId ?.find p = p.userId === userId ; if direct && this.isLevelSufficient direct.accessLevel, requiredLevel { return true; } // Check inherited permissions monorepo parent workspaces return this.checkInheritedAccess userId, projectId, requiredLevel ; } private isLevelSufficient given: AccessLevel, required: AccessLevel : boolean { const order: AccessLevel = 'read', 'write', 'admin' ; return order.indexOf given = order.indexOf required ; } private checkInheritedAccess userId: string, projectId: string, requiredLevel: AccessLevel, visited: Set<string = new Set , : boolean { if visited.has projectId return false; visited.add projectId ; const perms = this.permissions.get projectId ; if perms return false; for const perm of perms { if perm.userId == userId continue; if this.isLevelSufficient perm.accessLevel, requiredLevel return true; if perm.inheritedFrom { if this.checkInheritedAccess userId, perm.inheritedFrom, requiredLevel, visited { return true; } } } return false; } } Never allow sensitive data to be embedded in vectors. Add a pre-indexing scan: js // packages/indexer/src/secret-scanner.ts import { scan } from 'secret-scan'; export interface ScanResult { matched: boolean; secretType: string; lineNumber: number; } export async function scanForSecrets content: string : Promise<ScanResult { return scan content, { rules: { id: 'aws-access-key', pattern: /AKIA 0-9A-Z {16}/, severity: 'high' }, { id: 'github-token', pattern: /ghp 0-9a-zA-Z {36}/, severity: 'high' }, { id: 'private-key', pattern: /-----BEGIN RSA|EC|OPENSSH PRIVATE KEY-----/, severity: 'high' }, { id: 'jwt', pattern: /eyJ A-Za-z0-9 - +\.eyJ A-Za-z0-9 - +\. A-Za-z0-9 - +/, severity: 'medium' }, , } ; } export function filterSecrets content: string : string { return content.replace /AKIA 0-9A-Z {16}|ghp 0-9a-zA-Z {36}|-----BEGIN A-Z + PRIVATE KEY-----|eyJ A-Za-z0-9 - +/g, ' SECRET REDACTED ', ; } A RAG-assisted MCP tool has complex interactions between the language server, vector store, embedding model, and LLM. Test each layer independently and integrate at the boundaries. js // packages/indexer/ tests /strategies/typescript-strategy.test.ts import { describe, it, expect } from 'vitest'; import { TypeScriptChunkStrategy } from '../../src/strategies/typescript'; import { Chunk } from '../../src/types'; describe 'TypeScriptChunkStrategy', = { const strategy = new TypeScriptChunkStrategy { maxChunkSize: 500, overlapTokens: 50, } ; it 'splits a large class into logical chunks', = { const code = class UserService { async getUser id: string { return db.find id ; } async createUser data: CreateUserInput { return db.insert data ; } async deleteUser id: string { return db.remove id ; } async listUsers page: number { return db.paginate page ; } async updateUser id: string, data: Partial<CreateUserInput { return db.update id, data ; } } .trim ; const chunks = strategy.chunk { filePath: 'src/services/user.service.ts', content: code, language: 'typescript', } ; expect chunks .toHaveLengthGreaterThan 1 ; chunks.forEach chunk: Chunk = { expect chunk.content.length .toBeLessThanOrEqual 500 ; expect chunk.filePath .toBe 'src/services/user.service.ts' ; expect chunk.language .toBe 'typescript' ; } ; } ; it 'preserves imports and exports in chunk metadata', = { const code = import { injectable } from 'inversify'; export class CacheService implements ICacheService {} .trim ; const chunks = strategy.chunk { filePath: 'src/services/cache.service.ts', content: code, language: 'typescript', } ; expect chunks 0 .metadata.imports .toContain 'injectable' ; expect chunks 0 .metadata.exports .toContain 'CacheService' ; } ; } ; js // packages/mcp-server/ tests /tool-server.test.ts import { describe, it, expect, beforeEach, afterEach } from 'vitest'; import { MCPToolServer } from '../src/tool-server'; import { MockVectorStore } from './fixtures/mock-vector-store'; import { MockEmbeddingService } from './fixtures/mock-embedding-service'; describe 'MCPToolServer', = { let server: MCPToolServer; let vectorStore: MockVectorStore; let embeddingService: MockEmbeddingService; beforeEach = { vectorStore = new MockVectorStore ; embeddingService = new MockEmbeddingService ; server = new MCPToolServer { vectorStore, embeddingService, projectId: 'test-project', } ; } ; afterEach async = { await server.shutdown ; } ; it 'responds to ping', async = { const result = await server.handleRequest { jsonrpc: '2.0', id: 1, method: 'ping', } ; expect result.result .toEqual { status: 'ok' } ; } ; it 'searches codebase with semantic query', async = { await vectorStore.upsert 'test-project', { id: 'chunk-1', content: 'auth middleware validates JWT tokens', metadata: { filePath: 'src/middleware/auth.ts' } }, { id: 'chunk-2', content: 'database connection pool configuration', metadata: { filePath: 'src/db/pool.ts' } }, ; const result = await server.callTool { name: 'search codebase', arguments: { query: 'How do I configure authentication?', projectId: 'test-project', limit: 3, }, } ; expect result.content .toHaveLengthGreaterThan 0 ; expect result.content 0 .text .toContain 'auth' ; } ; it 'handles undefined project gracefully', async = { const result = await server.callTool { name: 'search codebase', arguments: { query: 'something', projectId: 'nonexistent-project', }, } ; expect result.isError .toBe true ; expect result.content 0 .text .toContain 'not indexed' ; } ; } ; js // packages/mcp-server/ tests /e2e/mcp-client-e2e.test.ts import { describe, it, expect, beforeAll, afterAll } from 'vitest'; import { Client } from '@modelcontextprotocol/sdk/client/index.js'; import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'; import { spawn } from 'child process'; describe 'E2E: MCP Tool Server', = { let client: Client; let serverProcess: ReturnType<typeof spawn ; beforeAll async = { serverProcess = spawn 'node', 'dist/mcp-server.js' , { env: { ...process.env, VECTOR STORE PATH: ':memory:', PROJECT ROOT: './ tests /fixtures/monorepo', }, } ; const transport = new StdioClientTransport serverProcess ; client = new Client { name: 'e2e-test-client', version: '1.0.0' }, { capabilities: {} }, ; await client.connect transport ; } ; afterAll async = { await client.close ; serverProcess.kill ; } ; it 'lists available tools', async = { const tools = await client.listTools ; const toolNames = tools.tools.map t = t.name ; expect toolNames .toContain 'search codebase' ; expect toolNames .toContain 'get file context' ; expect toolNames .toContain 'trace dependency' ; } ; it 'performs a full search-and-reason workflow', async = { // Search for auth-related code const searchResult = await client.callTool { name: 'search codebase', arguments: { query: 'JWT token validation', limit: 2, }, } ; expect searchResult.isError .toBe false ; // Get file context for the top result const firstResult = JSON.parse searchResult.content 0 .text ; const contextResult = await client.callTool { name: 'get file context', arguments: { filePath: firstResult.filePath, contextWindow: 50, }, } ; expect contextResult.isError .toBe false ; expect contextResult.content 0 .text.length .toBeGreaterThan 0 ; } ; } ; How do you know your RAG pipeline is performing well? You need both quantitative benchmarks and qualitative human evaluation. // packages/eval/src/golden-set.ts export interface GoldenQuestion { id: string; query: string; expectedFilePaths: string ; expectedChunkIds: string ; difficulty: 'easy' | 'medium' | 'hard'; category: 'finding' | 'understanding' | 'debugging' | 'refactoring'; } export const GOLDEN SET: GoldenQuestion = { id: 'q001', query: 'Where is the authentication middleware defined?', expectedFilePaths: 'packages/auth/src/middleware.ts' , expectedChunkIds: 'chunk-auth-middleware-1' , difficulty: 'easy', category: 'finding', }, { id: 'q002', query: 'How does the payment service handle retry logic for Stripe API calls?', expectedFilePaths: 'packages/payments/src/service.ts', 'packages/payments/src/retry.ts', , expectedChunkIds: 'chunk-payment-service', 'chunk-retry-logic' , difficulty: 'medium', category: 'understanding', }, { id: 'q003', query: 'There\'s a memory leak in the WebSocket handler. Where is the cleanup code?', expectedFilePaths: 'packages/ws/src/handler.ts' , expectedChunkIds: 'chunk-ws-handler-close' , difficulty: 'hard', category: 'debugging', }, ; js // packages/eval/src/evaluator.ts import { GoldenQuestion, GOLDEN SET } from './golden-set'; import { MCPToolServer } from 'monorepo-rag-mcp-server'; interface EvalResult { questionId: string; recall: number; // % of expected chunks retrieved precision: number; // % of retrieved chunks that are relevant f1: number; latencyMs: number; passed: boolean; } export class Evaluator { constructor private server: MCPToolServer {} async evaluate : Promise<EvalResult { const results: EvalResult = ; for const question of GOLDEN SET { const start = performance.now ; const searchResult = await this.server.callTool { name: 'search codebase', arguments: { query: question.query, limit: 10, }, } ; const latencyMs = performance.now - start; const retrievedChunks = this.parseChunksFromResult searchResult ; const { recall, precision, f1 } = this.computeMetrics retrievedChunks, question.expectedChunkIds, ; results.push { questionId: question.id, recall, precision, f1, latencyMs, passed: recall = 0.8 && precision = 0.7, } ; } return results; } private computeMetrics retrieved: string , expected: string , : { recall: number; precision: number; f1: number } { const retrievedSet = new Set retrieved ; const expectedSet = new Set expected ; const truePositives = ...retrievedSet .filter id = expectedSet.has id .length; const recall = expectedSet.size 0 ? truePositives / expectedSet.size : 0; const precision = retrievedSet.size 0 ? truePositives / retrievedSet.size : 0; const f1 = recall + precision 0 ? 2 recall precision / recall + precision : 0; return { recall, precision, f1 }; } private parseChunksFromResult result: unknown : string { // Implementation depends on your result format return ; } } | Metric | Target | Notes | |---|---|---| | Mean query latency | < 2s | Includes embedding + search | | P99 query latency | < 5s | During peak indexing | | Recall@10 on golden set | 85% | Minimum viable | | Precision@10 on golden set | 70% | Context window budget | | F1 across all questions | 0.75 | Balanced metric | | Index build time 10k files | < 15 min | Parallel embedding workers | Run pnpm eval after every chunking strategy change to track regressions. Here's a complete docker-compose.yml for running the full stack locally or in production: docker-compose.yml version: '3.9' services: embedding-server: build: context: ./packages/embedding-server dockerfile: ../../Dockerfile.embedding ports: - "6000:6000" environment: - MODEL ID=${EMBEDDING MODEL:-all-MiniLM-L6-v2} - MAX BATCH SIZE=32 - WORKERS=4 volumes: - embedding-cache:/app/.cache healthcheck: test: "CMD", "curl", "-f", "http://localhost:6000/health" interval: 30s timeout: 10s retries: 3 redis: image: redis:7-alpine ports: - "6379:6379" volumes: - redis-data:/data command: redis-server --appendonly yes healthcheck: test: "CMD", "redis-cli", "ping" interval: 10s timeout: 5s retries: 5 mcp-gateway: build: context: ./packages/mcp-gateway dockerfile: ../../Dockerfile.gateway ports: - "3000:3000" environment: - MCP SERVER URL=http://mcp-server:8080 - REDIS URL=redis://redis:6379 - EMBEDDING SERVER URL=http://embedding-server:6000 depends on: redis: condition: service healthy embedding-server: condition: service healthy healthcheck: test: "CMD", "curl", "-f", "http://localhost:3000/health" interval: 30s timeout: 10s retries: 3 mcp-server: build: context: ./packages/mcp-server dockerfile: ../../Dockerfile.mcp environment: - VECTOR STORE URL=http://embedding-server:6000 - REDIS URL=redis://redis:6379 - PROJECT ROOT=/data/monorepo volumes: - ./monorepo:/data/monorepo:ro depends on: redis: condition: service healthy embedding-server: condition: service healthy indexer-worker: build: context: ./packages/indexer dockerfile: ../../Dockerfile.worker environment: - REDIS URL=redis://redis:6379 - EMBEDDING SERVER URL=http://embedding-server:6000 - MAX CONCURRENCY=4 volumes: - ./monorepo:/data/monorepo:ro depends on: redis: condition: service healthy embedding-server: condition: service healthy volumes: redis-data: embedding-cache: Start everything with: docker compose up -d Then verify the health checks: curl http://localhost:3000/health curl http://localhost:6000/health .github/workflows/ci.yml name: CI on: push: branches: main pull request: branches: main jobs: test: runs-on: ubuntu-latest services: redis: image: redis:7-alpine ports: '6379:6379' qdrant: image: qdrant/qdrant:latest ports: '6333:6333' steps: - uses: actions/checkout@v4 - name: Setup Node uses: actions/setup-node@v4 with: node-version: '20' cache: 'pnpm' - name: Install dependencies run: pnpm install --frozen-lockfile - name: Type check run: pnpm --filter monorepo-rag-mcp... typecheck - name: Lint run: pnpm --filter monorepo-rag-mcp... lint - name: Unit tests run: pnpm --filter monorepo-rag-mcp... test:unit - name: Integration tests run: pnpm --filter monorepo-rag-mcp-server test:integration env: REDIS URL: redis://localhost:6379 VECTOR STORE URL: http://localhost:6333 - name: E2E tests run: pnpm --filter monorepo-rag-mcp-server test:e2e env: REDIS URL: redis://localhost:6379 EMBEDDING SERVER URL: http://localhost:6000 - name: Evaluate run: pnpm --filter monorepo-rag-mcp-eval eval env: REDIS URL: redis://localhost:6379 - name: Build run: pnpm build - name: Docker build gateway run: docker build -f Dockerfile.gateway -t mcp-gateway:${{ github.sha }} . - name: Docker build mcp server run: docker build -f Dockerfile.mcp -t mcp-server:${{ github.sha }} . Add this to your .vscode/settings.json : { "mcp.servers": { "monorepo-rag": { "type": "stdio", "command": "node", "args": "/path/to/packages/mcp-gateway/dist/index.js" , "env": { "PROJECT ROOT": "/path/to/your/monorepo", "REDIS URL": "redis://localhost:6379", "EMBEDDING SERVER URL": "http://localhost:6000" } } } } Or use the official MCP client extension: { "mcpServers": { "monorepo-rag-mcp": { "command": "npx", "args": "-y", "monorepo-rag-mcp-gateway" , "env": { "PROJECT ROOT": "${workspaceFolder}", "EMBEDDING MODEL": "all-MiniLM-L6-v2" } } } } For Cursor, add to .cursor/mcp.json : { "mcpServers": { "monorepo-rag": { "command": "node", "args": "dist/mcp-gateway.js" , "env": { "PROJECT ROOT": "/path/to/monorepo" } } } } For JetBrains IDEs with the MCP plugin, use the same configuration format in the plugin settings panel. Once connected, you'll see tools like these in your AI assistant's tool palette: If your chunks are too small, the LLM loses context. If too large, retrieval becomes noisy. Start with 300–500 tokens and measure recall at different sizes. js // packages/indexer/src/chunker.ts const CHUNK SIZES = 200, 300, 500, 800, 1200 ; export function findOptimalChunkSize projectId: string, sampleQueries: string , : number { let bestSize = CHUNK SIZES 0 ; let bestScore = 0; for const size of CHUNK SIZES { const strategy = new SmartChunker { maxChunkSize: size, overlapTokens: Math.floor size 0.1 } ; const score = evaluateStrategy projectId, strategy, sampleQueries ; if score bestScore { bestScore = score; bestSize = size; } } return bestSize; } Files change. Your index must reflect reality. Use filesystem watchers combined with periodic full re-indexes: js // packages/indexer/src/watcher.ts import { watch } from 'chokidar'; import { IndexService } from './index-service'; export function startFileWatcher projectRoot: string, indexService: IndexService, projectId: string, { const watcher = watch projectRoot, { ignored: /node modules|\.git|dist|build|\.next/, persistent: true, depth: 10, } ; watcher .on 'add', async path = { await indexService.indexFile projectId, path ; } .on 'change', async path = { await indexService.reindexFile projectId, path ; } .on 'unlink', async path = { await indexService.removeFile projectId, path ; } ; // Full reindex every 6 hours as a safety net setInterval = { indexService.reindexAll projectId ; }, 6 60 60 1000 ; } Switching embedding models changes vector semantics. Never swap models without re-embedding the entire corpus, or you'll get incomparable vectors in the store: // packages/indexer/src/migration.ts export interface ModelMigration { fromModel: string; toModel: string; requiresReindex: boolean; notes: string; } const MIGRATIONS: Record<string, ModelMigration = { 'all-MiniLM-L6-v2- text-embedding-3-small': { fromModel: 'all-MiniLM-L6-v2', toModel: 'text-embedding-3-small', requiresReindex: true, notes: 'Dimensionality change: 384 - 1536. Full re-index required.', }, }; export function validateModelSwap currentModel: string, newModel: string : void { const migration = MIGRATIONS ${currentModel}- ${newModel} ; if migration return; if migration.requiresReindex { throw new Error Cannot switch from ${currentModel} to ${newModel} without re-indexing. ${migration.notes} ; } } When the MCP tool returns results, the IDE's AI may also have access to the open files. This can cause the model to prefer IDE context over retrieved context. Mitigate by clearly labeling retrieved results: // packages/mcp-server/src/responses.ts export function formatSearchResult query: string, results: SearchResult : string { const lines = Search Results for: "${query}" , Found ${results.length} relevant code chunks from ${new Set results.map r = r.filePath .size} files. , --- , ; for const result of results { lines.push \n \ ${result.filePath}\ relevance: ${ result.score 100 .toFixed 1 }% ; lines.push result.content ; lines.push --- ; } return lines.join '\n' ; } Building a codebase intelligence tool like repowise with a RAG-assisted MCP for your monorepo is a substantial engineering effort—but one that pays compounding dividends. Every developer on the team gains instant, semantic access to the entire codebase without context-switching between IDE, documentation, and search tools. The key architectural decisions that determine success are: The codebase structure we've outlined—five focused packages under a pnpm workspace—gives you a foundation that scales. The indexer handles the heavy lifting of turning code into searchable vectors. The embedding-server provides a stable, language-agnostic embedding interface. The vector-store abstraction lets you move between Qdrant, Weavi