Create MCP Server for codebase_search to Enable Semantic Code Search for External AI Agents pls

[b9348]

i dont know english, all text create by llm

Body

Summary

I would like to request the development of an MCP (Model Context Protocol) server that exposes Roo-Code's powerful codebase_search functionality. This would allow other AI agents and tools (such as Claude CLI, Gemini CLI, and other MCP-compatible systems) to leverage Roo-Code's semantic search capabilities for code exploration and understanding.

Background

Roo-Code currently includes an excellent semantic search tool called codebase_search 1 that uses vector embeddings to find relevant code based on meaning rather than exact text matches 2 . This tool is particularly effective for understanding how features are implemented across multiple files and discovering API usage patterns 3 .

Proposed Solution

Create a standalone MCP server that:

1. Exposes the core search functionality: Wrap the existing CodeIndexManager and search logic 4 into an MCP-compatible interface

2. Provides semantic search tools: Offer tools similar to the current codebase_search implementation with parameters for:

   • query: Natural language search query
   • path: Optional directory filtering
   • Configuration for embedding providers (OpenAI, Ollama, etc.)

3. Maintains the same quality: Preserve the current search result format including file paths, similarity scores, line numbers, and code chunks 5

Benefits

• Broader ecosystem adoption: Enable other AI coding assistants to benefit from Roo-Code's semantic search technology
• Standardized interface: Provide a consistent way for different tools to access semantic code search
• Community growth: Potentially attract more users to the Roo-Code ecosystem through MCP integration
• Reduced duplication: Prevent other projects from having to rebuild similar semantic search capabilities

Technical Considerations

The MCP server would need to:

• Handle code indexing and vector storage (currently using Qdrant) 6
• Support multiple embedding providers
• Manage workspace-specific indexes
• Provide proper error handling and configuration validation

Use Cases

This would enable semantic code search in:

• Claude CLI for enhanced code exploration
• Gemini CLI for better context understanding
• Custom MCP-compatible development tools
• IDE extensions that support MCP
• Automated code analysis pipelines

Would the maintainers be interested in developing such an MCP server, or would you be open to community contributions for this feature?

Notes

The request focuses on extracting the core semantic search functionality from Roo-Code's codebase_search tool and making it available as a standalone MCP server. This would allow the powerful semantic search capabilities currently exclusive to Roo-Code users to be leveraged by other AI development tools in the ecosystem. The technical implementation would likely involve refactoring the existing CodeIndexManager and search logic into a server that can be consumed by any MCP-compatible client.

Wiki pages you might want to explore:

• System Architecture Overview (RooCodeInc/Roo-Code)
• Modes and Tool Management (RooCodeInc/Roo-Code)

Citations

File: src/core/tools/codebaseSearchTool.ts (L1-25)

import * as vscode from "vscode"

import { Task } from "../task/Task"
import { CodeIndexManager } from "../../services/code-index/manager"
import { getWorkspacePath } from "../../utils/path"
import { formatResponse } from "../prompts/responses"
import { VectorStoreSearchResult } from "../../services/code-index/interfaces"
import { AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolUse } from "../../shared/tools"
import path from "path"

export async function codebaseSearchTool(
	cline: Task,
	block: ToolUse,
	askApproval: AskApproval,
	handleError: HandleError,
	pushToolResult: PushToolResult,
	removeClosingTag: RemoveClosingTag,
) {
	const toolName = "codebase_search"
	const workspacePath = (cline.cwd && cline.cwd.trim() !== '') ? cline.cwd : getWorkspacePath()

	if (!workspacePath) {
		// This case should ideally not happen if Cline is initialized correctly
		await handleError(toolName, new Error("Could not determine workspace path."))
		return

File: src/core/tools/codebaseSearchTool.ts (L72-85)

		const manager = CodeIndexManager.getInstance(context)

		if (!manager) {
			throw new Error("CodeIndexManager is not available.")
		}

		if (!manager.isFeatureEnabled) {
			throw new Error("Code Indexing is disabled in the settings.")
		}
		if (!manager.isFeatureConfigured) {
			throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).")
		}

		const searchResults: VectorStoreSearchResult[] = await manager.searchIndex(query, directoryPrefix)

File: src/core/tools/codebaseSearchTool.ts (L97-119)

			query: string
			results: Array<{
				filePath: string
				score: number
				startLine: number
				endLine: number
				codeChunk: string
			}>
		}

		searchResults.forEach((result) => {
			if (!result.payload) return
			if (!("filePath" in result.payload)) return

			const relativePath = vscode.workspace.asRelativePath(result.payload.filePath, false)

			jsonResult.results.push({
				filePath: relativePath,
				score: result.score,
				startLine: result.payload.startLine,
				endLine: result.payload.endLine,
				codeChunk: result.payload.codeChunk.trim(),
			})

File: src/core/prompts/tools/codebase-search.ts (L4-5)

	return `## codebase_search
Description: Find files most relevant to the search query using semantic search. Searches based on meaning rather than exact text matches. By default searches entire workspace. Reuse the user's exact wording unless there's a clear reason not to - their phrasing often helps semantic search. Queries MUST be in English (translate if needed).

File: src/core/prompts/sections/capabilities.ts (L24-25)

			? `
- You can use the \`codebase_search\` tool to perform semantic searches across your entire codebase. This tool is powerful for finding functionally relevant code, even if you don't know the exact keywords or file names. It's particularly useful for understanding how features are implemented across multiple files, discovering usages of a particular API, or finding code examples related to a concept. This capability relies on a pre-built index of your code.`