@morphllm/morphmcp 0.8.13 → 0.8.14

package/README.md

@@ -6,7 +6,8 @@ Unified Model Context Protocol (MCP) server providing AI-powered file editing an
 
 ### AI-Powered Tools
 - **Fast Apply (edit_file)** - Morph's lightning-fast code editing at 10,500+ tokens/sec with 98% accuracy
-- **Fast Context Search (fast_context_search)** - AI-powered code search using WarpGrep that intelligently explores repositories to find relevant code
+- **Semantic Search (codebase_search)** - Natural language code search using embeddings and GPU reranking for finding relevant code across your codebase
+- **Fast Context Search (fast_context_search)** - AI-powered grep agent using WarpGrep that intelligently explores repositories to find relevant code
 
 ### Filesystem Operations
 - Read/write files with memory-efficient head/tail operations
@@ -29,33 +30,36 @@ Unified Model Context Protocol (MCP) server providing AI-powered file editing an
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `MORPH_API_KEY` | Your Morph API key (required for AI tools) | - |
-| `ENABLED_TOOLS` | Comma-separated list of enabled tools, or `all` | `edit_file,fast_context_search` |
+| `ENABLED_TOOLS` | Comma-separated list of enabled tools, or `all` | `edit_file,codebase_search` |
 | `MORPH_DEBUG` | Enable debug logging for grep agent (`true`/`false`) | `false` |
 | `ENABLE_WORKSPACE_MODE` | Auto-detect workspace root (`true`/`false`) | `true` |
 | `WORKSPACE_ROOT` | Override workspace root directory | `$PWD` |
 
 ### Tool Configuration
 
-Control which tools are available using `ENABLED_TOOLS`. **By default, only AI-powered tools (`edit_file` and `fast_context_search`) are enabled** to keep the interface clean. Enable additional filesystem tools as needed:
+Control which tools are available using `ENABLED_TOOLS`. **By default, only AI-powered tools (`edit_file` and `codebase_search`) are enabled** to keep the interface clean. Enable additional filesystem tools as needed:
 
 ```bash
 # Default: Only AI-powered tools
-# (No ENABLED_TOOLS needed - edit_file and fast_context_search are enabled by default)
+# (No ENABLED_TOOLS needed - edit_file and codebase_search are enabled by default)
 
 # Enable all tools including filesystem operations
 ENABLED_TOOLS=all
 
 # Only AI-powered tools (explicit, same as default)
-ENABLED_TOOLS=edit_file,fast_context_search
+ENABLED_TOOLS=edit_file,codebase_search
 
 # Only fast apply
 ENABLED_TOOLS=edit_file
 
-# Only context search
-ENABLED_TOOLS=fast_context_search
+# Only semantic search
+ENABLED_TOOLS=codebase_search
+
+# Include fast_context_search (grep agent)
+ENABLED_TOOLS=edit_file,codebase_search,fast_context_search
 
 # Custom selection
-ENABLED_TOOLS=read_file,write_file,edit_file,fast_context_search
+ENABLED_TOOLS=read_file,write_file,edit_file,codebase_search
 ```
 
 ## Available Tools
@@ -77,6 +81,62 @@ ENABLED_TOOLS=read_file,write_file,edit_file,fast_context_search
 
 **Note for Cursor users:** If you're using this tool within Cursor, you may need to first use another tool (like `search_replace`) to add exactly one empty newline somewhere in the file before using `edit_file`. This ensures the file is in an editable state.
 
+#### `codebase_search`
+**SEMANTIC CODE SEARCH** - Find code using natural language queries. Uses two-stage retrieval (vector search + GPU reranking) to find the most relevant code across your entire codebase.
+
+**Key features:**
+- Natural language queries: "Where is JWT validation?" or "How does auth work?"
+- Two-stage retrieval: Vector search (~240ms) + GPU reranking (~630ms)
+- Returns precise code chunks with relevance scores
+- Searches by semantic meaning, not just keywords
+- Works across all files and languages
+
+**Requires:** `MORPH_API_KEY` and code pushed to Morph git
+
+**How it works:**
+```
+┌─────────────────────────────────────────────────────────────┐
+│  SEMANTIC SEARCH LIFECYCLE                                  │
+└─────────────────────────────────────────────────────────────┘
+
+1. CODE CHANGES                    2. AUTO-SYNC (Plugin)
+   ┌─────────────┐                    ┌─────────────┐
+   │ Agent edits │ ──────────────────> │ git commit  │
+   │   files     │                     │ + push      │
+   └─────────────┘                     └──────┬──────┘
+                                              │
+                                              ▼
+3. EMBEDDING (3-8s)                4. INDEXED & SEARCHABLE
+   ┌─────────────────┐                ┌──────────────────┐
+   │ Code chunking   │                │ PostgreSQL       │
+   │ morph-v4-embed  │ ────────────>  │ pgvector (HNSW)  │
+   │ Vector storage  │                │ Ready for search │
+   └─────────────────┘                └────────┬─────────┘
+                                               │
+                                               ▼
+5. SEARCH QUERY                    6. TWO-STAGE RETRIEVAL
+   ┌─────────────────┐                ┌──────────────────┐
+   │ "Find auth      │                │ Vector: top 50   │
+   │  logic"         │ ────────────>  │ Rerank: top 10   │
+   └─────────────────┘                │ ~1000ms total    │
+                                      └────────┬─────────┘
+                                               │
+                                               ▼
+7. RESULTS                         8. AGENT USES CONTEXT
+   ┌─────────────────┐                ┌──────────────────┐
+   │ Ranked code     │                │ Makes informed   │
+   │ with scores     │ ────────────>  │ edits with       │
+   │ + line numbers  │                │ relevant context │
+   └─────────────────┘                └──────────────────┘
+```
+
+**Setup:** Install the `morph-sync` plugin to automatically sync code after every agent response. See [Enable Semantic Search](#enable-semantic-search-with-morph-sync-plugin) below.
+
+**Example queries:**
+- "Where is JWT validation implemented?"
+- "How does the authentication middleware work?"
+- "Find database connection setup"
+
 #### `fast_context_search`
 Intelligently search and gather relevant code context from a repository using Morph's WarpGrep AI-powered search agent. Automatically explores the codebase with grep, file reading, and directory analysis to find exactly what you need.
 
@@ -228,12 +288,12 @@ Or manually add to `.vscode/mcp.json`:
 }
 ```
 
-**For code search only:**
+**For semantic code search only:**
 ```json
 {
   "env": {
     "MORPH_API_KEY": "sk-...",
-    "ENABLED_TOOLS": "fast_context_search"
+    "ENABLED_TOOLS": "codebase_search"
   }
 }
 ```
@@ -253,16 +313,27 @@ Or manually add to `.vscode/mcp.json`:
 {
   "env": {
     "MORPH_API_KEY": "sk-..."
-    // ENABLED_TOOLS defaults to edit_file,fast_context_search
+    // ENABLED_TOOLS defaults to edit_file,codebase_search
   }
 }
 ```
 
-### 3. Test Your Setup
+### 3. Enable Semantic Search (Optional but Recommended)
+
+For the `codebase_search` tool to work, code must be synced to Morph git. Install the `morph-sync` plugin:
+
+**In Claude Code:**
+```bash
+/plugin install morph-sync
+```
+
+The plugin automatically commits and pushes code after every agent response, triggering embedding in the background (3-8 seconds).
+
+### 4. Test Your Setup
 
 In your AI assistant, try:
 - **Edit test:** "Use the edit_file tool to add a comment to the main function"
-- **Search test:** "Use fast_context_search to find where database connections are initialized"
+- **Search test:** "Find the authentication logic in this codebase" (uses codebase_search)
 
 ## Usage Examples
 
@@ -279,6 +350,22 @@ The AI will:
 5. Report errors (if any) to Morph for continuous improvement
 ```
 
+### Semantic Code Search
+
+```
+Ask AI: "Find the authentication logic in this codebase"
+
+The codebase_search tool will:
+1. Query the embedded codebase using natural language
+2. Vector search retrieves top 50 candidates (~240ms)
+3. GPU reranking scores for precision (~630ms)
+4. Return top 10 most relevant code chunks with scores
+5. Include file paths, line numbers, and relevance percentages
+6. Agent uses this context to make informed edits
+
+Note: Requires code to be synced via morph-sync plugin
+```
+
 ### Fast Context Search
 
 ```

package/dist/index.js

@@ -14,6 +14,7 @@ import { isPathWithinAllowedDirectories } from './path-validation.js';
 import { getValidRootDirectories } from './roots-utils.js';
 import { executeEditFile } from '@morphllm/morphsdk/tools/fastapply';
 import { runWarpGrep, LocalRipgrepProvider } from '@morphllm/morphsdk/tools/warp-grep';
+import { CodebaseSearchClient } from '@morphllm/morphsdk/tools/codebase-search';
 import axios from "axios";
 // Command line argument parsing
 const args = process.argv.slice(2);
@@ -33,13 +34,14 @@ const ALL_TOOLS = [
     'get_file_info',
     'list_allowed_directories',
     'edit_file',
-    'fast_context_search'
+    'fast_context_search',
+    'codebase_search'
 ];
 // Only expose Morph-specific tools by default
 // Other filesystem tools remain available for internal use and via ENABLED_TOOLS env var
 const DEFAULT_TOOLS = [
     'edit_file',
-    'fast_context_search'
+    'codebase_search'
 ];
 // Parse ENABLED_TOOLS env var: comma-separated list or 'all'
 const ENABLED_TOOLS = process.env.ENABLED_TOOLS
@@ -268,6 +270,14 @@ const FastContextSearchArgsSchema = z.object({
     repoPath: z.string().describe("Path to the repository root"),
     query: z.string().describe("Natural language query describing the code context needed"),
 });
+const CodebaseSearchArgsSchema = z.object({
+    query: z.string().describe('Natural language query to search for code'),
+    repoId: z.string().describe('Repository identifier'),
+    branch: z.string().optional().describe('Branch to search (uses latest commit)'),
+    commitHash: z.string().optional().describe('Specific commit hash to search'),
+    target_directories: z.array(z.string()).default([]).describe('Filter to specific directories, empty for all'),
+    limit: z.number().optional().default(10).describe('Max results to return')
+});
 const ToolInputSchema = ToolSchema.shape.inputSchema;
 // Server setup
 const server = new Server({
@@ -650,6 +660,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             inputSchema: zodToJsonSchema(FastContextSearchArgsSchema),
             requiresApiKey: true,
         },
+        {
+            name: "codebase_search",
+            description: "**SEMANTIC CODE SEARCH - USE FOR FINDING CODE**\n\n" +
+                "⚡ INTELLIGENT: Natural language search across your entire codebase using AI embeddings.\n" +
+                "🎯 USE THIS TOOL to find code when you need to understand existing implementations.\n\n" +
+                "Benefits:\n" +
+                "- Two-stage retrieval: vector search (~240ms) + GPU reranking (~630ms)\n" +
+                "- Returns precise code chunks with relevance scores\n" +
+                "- Searches by semantic meaning, not just keywords\n" +
+                "- Works across all files and languages\n\n" +
+                "Search your codebase using natural language queries. Code must be pushed to Morph git first (see Repo Storage docs). " +
+                "Returns ranked code chunks with relevance scores, file paths, and line numbers. " +
+                "Example queries: 'Where is JWT validation?', 'How does auth work?', 'Find database connection logic'.",
+            inputSchema: zodToJsonSchema(CodebaseSearchArgsSchema),
+            requiresApiKey: true,
+        },
     ];
     // Filter tools based on ENABLED_TOOLS and API key availability
     const availableTools = allTools.filter(tool => {
@@ -1152,6 +1178,64 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
             }
+            case "codebase_search": {
+                const parsed = CodebaseSearchArgsSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Invalid arguments: ${parsed.error}` }],
+                        isError: true,
+                    };
+                }
+                try {
+                    const apiKey = MORPH_API_KEY;
+                    if (!apiKey) {
+                        throw new Error('MORPH_API_KEY environment variable must be set in MCP config.');
+                    }
+                    const client = new CodebaseSearchClient({ apiKey, debug: false });
+                    const result = await client.search({
+                        query: parsed.data.query,
+                        repoId: parsed.data.repoId,
+                        branch: parsed.data.branch,
+                        commitHash: parsed.data.commitHash,
+                        target_directories: parsed.data.target_directories,
+                        limit: parsed.data.limit
+                    });
+                    if (!result.success) {
+                        return {
+                            content: [{ type: "text", text: `Search failed: ${result.error}` }],
+                            isError: true,
+                        };
+                    }
+                    // Format results
+                    const resultText = result.results.length === 0
+                        ? `No results found for query: "${parsed.data.query}"`
+                        : `Found ${result.results.length} results in ${result.stats.searchTimeMs}ms:\n\n` +
+                            result.results.map((r, i) => `${i + 1}. ${r.filepath} (${(r.rerankScore * 100).toFixed(1)}% match)\n` +
+                                `   Lines ${r.startLine}-${r.endLine}\n` +
+                                `   ${r.content.substring(0, 200)}${r.content.length > 200 ? '...' : ''}\n`).join('\n');
+                    return {
+                        content: [{ type: "text", text: resultText }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    reportMorphError({
+                        error_message: errorMessage,
+                        error_type: error instanceof Error ? error.constructor.name : 'UnknownError',
+                        context: {
+                            tool: 'codebase_search',
+                            query: parsed.data.query,
+                            repo_id: parsed.data.repoId
+                        },
+                        stack_trace: error instanceof Error ? error.stack : undefined,
+                        source: 'mcp-filesystem'
+                    }).catch(() => { });
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                        isError: true,
+                    };
+                }
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphllm/morphmcp",
-  "version": "0.8.13",
+  "version": "0.8.14",
   "description": "Fast & accurate MCP server with AI-powered file editing and intelligent code search. Prevents context pollution and saves time for a better user experience.",
   "license": "MIT",
   "author": "Morph (https://morphllm.com)",