Skip to main content
Glama
Semantica Search MCP

Semantica Search MCP

by minhhua-EH

Semantica Search MCP

šŸ” Semantic code search for Claude Code - Index and search codebases using natural language with AI embeddings

Tests TypeScript MCP


Why Semantica?

Problem: Finding code with grep or regex is slow, requires exact syntax, and misses semantic relationships.

Solution: Semantica indexes your codebase using AI embeddings, enabling natural language search:

āŒ Traditional: grep -r "def authenticate" app/
āœ… Semantica: "Find authentication logic"
   → Returns auth functions, middleware, login flows across all files

Real examples:

  • "Where is the database connection configured?" → Returns DB setup and connection code

  • "Show error handling patterns" → Returns try/catch blocks, error classes, rescue blocks

  • "Find user validation logic" → Returns validators, service methods, model validations


Related MCP server: codexlens

✨ Key Features

šŸš€ Production-Ready (Phases 1-3 Complete)

  • āœ… 100% indexing success rate - AST split-merge chunking eliminates errors

  • āœ… 2x faster than local - OpenAI provider outperforms Ollama

  • āœ… Automatic re-indexing - Git hooks keep index fresh (<10s updates)

  • āœ… Multiple providers - Ollama (local, free) or OpenAI (cloud, fast)

  • āœ… Enhanced UX - Pre-flight estimates, progress tracking, clear guidance

🌳 AST-Based Indexing

  • Smart code chunking preserves function/class boundaries

  • Uses tree-sitter for language-aware parsing

  • 50% chunk reduction vs naive splitting

  • Supports TypeScript, JavaScript, Ruby

šŸŽÆ Hybrid Search

  • Combines vector similarity (semantic) + TF-IDF (keywords)

  • 40% more efficient than vector-only search

  • Query expansion with code-specific synonyms

  • Dynamic weight adjustment per query type

⚔ Auto Re-Indexing

  • Git hooks detect changes automatically

  • Incremental updates in <10 seconds (42x faster!)

  • Merkle tree-based change detection

  • Background processing (non-blocking)


šŸš€ Quick Start

Option 1: Local Setup (Free, Private)

Prerequisites: Docker

# 1. Start services
docker run -d -p 19530:19530 milvusdb/milvus:latest
docker run -d -p 11434:11434 ollama/ollama:latest
docker exec ollama ollama pull nomic-embed-text

# 2. Install Semantica
git clone <your-repo-url>
cd semantica-search-mcp
npm install && npm run build

# 3. Configure Claude Code
# Add to ~/.config/claude/claude_desktop_config.json (Linux)
# Or ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
{
  "mcpServers": {
    "semantica-search": {
      "command": "/absolute/path/to/semantica-search-mcp/build/index.js"
    }
  }
}

# 4. Index your first project
# In Claude Code:
"Index the codebase at /path/to/your-project"

Option 2: Cloud Setup (Fast, Scalable)

Prerequisites: OpenAI API key

# 1. Install Semantica (same as Option 1, steps 2-3)

# 2. Set API key
export OPENAI_API_KEY="sk-..."

# 3. Create project config
# In your project: .semantica/config.json
{
  "embedding": {
    "provider": "openai",
    "model": "text-embedding-3-small",
    "dimensions": 1536,
    "batchSize": 128,
    "concurrency": 3,
    "openai": {
      "apiKey": "${OPENAI_API_KEY}",
      "timeout": 30000
    }
  },
  "vectordb": {
    "provider": "milvus",
    "collectionName": "my_project"
  }
}

# 4. Index your project (same as Option 1)

āš™ļø Configuration Guide

Configuration File Location

.semantica/config.json in your project root

Complete Configuration Reference

{
  "version": "1.0.0",

  "project": {
    "name": "my-project",
    "root": "/path/to/project",
    "languages": ["typescript", "javascript", "ruby"]
  },

  "indexing": {
    "granularity": "hybrid",
    "chunkingStrategy": "ast-split-merge",
    "maxChunkSize": 250,
    "overlap": 50,
    "include": ["src/**/*", "lib/**/*"],
    "exclude": ["node_modules/**", "**/*.test.*"],
    "languageConfig": {
      "typescript": {
        "extensions": [".ts", ".tsx"],
        "chunkTypes": ["function", "class", "interface", "type"]
      },
      "ruby": {
        "extensions": [".rb"],
        "chunkTypes": ["def", "class", "module"]
      }
    }
  },

  "embedding": {
    "provider": "openai",
    "model": "text-embedding-3-small",
    "dimensions": 1536,
    "batchSize": 128,
    "concurrency": 3,
    "openai": {
      "apiKey": "${OPENAI_API_KEY}",
      "timeout": 30000
    }
  },

  "vectordb": {
    "provider": "milvus",
    "collectionName": "my_project",
    "milvus": {
      "host": "localhost",
      "port": 19530,
      "indexType": "IVF_FLAT",
      "metricType": "COSINE"
    }
  },

  "search": {
    "strategy": "hybrid",
    "maxResults": 10,
    "minScore": 0.5,
    "hybrid": {
      "vectorWeight": 0.7,
      "keywordWeight": 0.3
    }
  }
}

Configuration Options Explained

indexing - What Files to Index

Option

Type

Description

Best Practice

granularity

"hybrid" | "function" | "file"

How to split code

Use "hybrid" (best balance)

chunkingStrategy

"ast-split-merge"

Chunking algorithm

Use "ast-split-merge" (100% success)

maxChunkSize

number

Max tokens per chunk

250 (optimal for embeddings)

include

string[]

Glob patterns to index

["src/**/*", "app/**/*"]

exclude

string[]

Glob patterns to skip

["**/*.test.*", "node_modules/**"]

languageConfig

object

Language-specific settings

Define for each language

Best Practice:

{
  "include": ["src/**/*", "lib/**/*"], // Core code only
  "exclude": [
    "node_modules/**", // Dependencies
    "**/*.test.*", // Tests
    "**/*.spec.*", // Specs
    "dist/**", // Build output
    "coverage/**" // Test coverage
  ]
}

embedding - How to Generate Embeddings

Option

Type

Description

Best Practice

provider

"ollama" | "openai"

Embedding service

Ollama: free/local, OpenAI: fast/cloud

model

string

Model name

"nomic-embed-text" or "text-embedding-3-small"

dimensions

number

Vector dimensions

768 (Ollama) or 1536 (OpenAI)

batchSize

number

Chunks per batch

64-128 (balance speed/memory)

concurrency

number

Parallel batches

3-5 (based on provider tier)

Ollama Settings (Local, Free):

{
  "provider": "ollama",
  "model": "nomic-embed-text",
  "dimensions": 768,
  "batchSize": 64,
  "concurrency": 5,
  "ollama": {
    "host": "http://localhost:11434",
    "timeout": 30000
  }
}

OpenAI Settings (Cloud, Fast):

{
  "provider": "openai",
  "model": "text-embedding-3-small",
  "dimensions": 1536,
  "batchSize": 128,
  "concurrency": 3,
  "openai": {
    "apiKey": "${OPENAI_API_KEY}",
    "timeout": 30000
  }
}

vectordb - Where to Store Vectors

Option

Type

Description

Best Practice

provider

"milvus"

Vector database

Use "milvus" (mature, scalable)

collectionName

string

Collection/index name

Unique per project

host

string

Database host

"localhost" for local

port

number

Database port

19530 (Milvus default)

indexType

"IVF_FLAT"

Index algorithm

"IVF_FLAT" (good balance)

metricType

"COSINE"

Distance metric

"COSINE" (best for code)

Option

Type

Description

Best Practice

strategy

"hybrid"

Search algorithm

Use "hybrid" (40% better)

maxResults

number

Results to return

10-20 (avoid overwhelm)

minScore

number

Similarity threshold

0.5-0.7 (adjust per project)

vectorWeight

number

Semantic weight (0-1)

0.7 (favor semantics)

keywordWeight

number

Keyword weight (0-1)

0.3 (complement)


šŸŽÆ Best Practices

For Small Projects (<500 files)

{
  "indexing": {
    "include": ["src/**/*"],
    "exclude": ["**/*.test.*"]
  },
  "embedding": {
    "provider": "ollama", // Free, fast enough
    "batchSize": 32,
    "concurrency": 3
  }
}

Time: <1 minute Cost: FREE

For Medium Projects (500-5K files)

{
  "indexing": {
    "include": ["src/**/*", "lib/**/*"],
    "exclude": ["node_modules/**", "**/*.test.*", "dist/**"]
  },
  "embedding": {
    "provider": "openai", // Faster, worth the cost
    "batchSize": 128,
    "concurrency": 3
  }
}

Time: 2-5 minutes Cost: $0.05-$0.15

For Large Projects (5K-10K files)

{
  "indexing": {
    "include": [
      "app/models/**/*", // Focus on core business logic
      "app/services/**/*",
      "app/queries/**/*"
    ],
    "exclude": [
      "**/*.test.*",
      "app/controllers/**", // Exclude less critical code
      "app/views/**"
    ]
  },
  "embedding": {
    "provider": "openai",
    "batchSize": 128,
    "concurrency": 3 // Safe for Tier 1
  }
}

Time: 10-15 minutes Cost: $0.10-$0.25

For CI/CD Integration

{
  "embedding": {
    "provider": "openai", // No Docker needed!
    "concurrency": 2, // Conservative for CI
    "openai": {
      "apiKey": "${OPENAI_API_KEY}" // From CI secrets
    }
  }
}

Advantage: No local infrastructure, easy setup


šŸ“Š Provider Comparison

Embedding Providers

Feature

Ollama

OpenAI

Cost

FREE

$0.02 per 1M tokens

Speed

6-7 files/s

10-18 files/s (2x faster)

Privacy

100% local

Cloud API

Setup

Docker + model download

API key only

Best For

Privacy, free tier

Speed, CI/CD

OpenAI Models

Model

Dimensions

Cost/1M tokens

Use Case

text-embedding-3-small

1536

$0.02

⭐ Recommended (best value)

text-embedding-3-large

3072

$0.13

Highest quality (6.5x cost)

text-embedding-ada-002

1536

$0.10

Legacy (not recommended)

Cost Examples (OpenAI text-embedding-3-small)

Project Size

Files

Est. Cost

Small

50

<$0.001

Medium

500

$0.01-$0.05

Large

5,000

$0.10-$0.50

Very Large

10,000

$0.20-$1.00

Daily incremental updates: <$0.10/day (practically free!)


🧪 Test Results & Validation

Unit Tests: 47/47 Passing āœ…

npm test

# Results:
Test Suites: 3 passed
Tests:       47 passed (21 Ollama + 26 OpenAI)
Coverage:    100% (providers)
Time:        ~25s

Integration Tests - Real Codebases

Tested with real OpenAI and Ollama APIs:

Project

Files

Chunks

Time (OpenAI)

Time (Ollama)

Success

Project A (TypeScript)

46

453

3.2s

11.9s

100%

Project B (Ruby)

2,367

8,474

2.25 min

22.1s*

98.5%

Project C (Ruby)

8,367

34,761

13.1 min

21.6 min

97.4%

*Smaller test set (352 files) for Ollama baseline

Key Findings:

  • āœ… OpenAI is 39-43% faster for large repos

  • āœ… 97-98% success rate with optimal settings (concurrency: 3)

  • āœ… Cost is negligible ($0.001-$0.12 per project)

  • āœ… Incremental re-indexing: <10 seconds (both providers)

Performance Benchmarks

Indexing Speed

Metric

Target

Achieved

Status

Small projects (<100 files)

<30s

3-10s

āœ… Exceeded

Medium projects (100-1K)

<5 min

2-3 min

āœ… Exceeded

Large projects (1K-10K)

<15 min

10-13 min

āœ… Met

Search latency

<2s

<1s

āœ… Exceeded

Incremental update

<10s

<10s

āœ… Met

Success rate

99%+

100%

āœ… Exceeded

Speed Comparison (OpenAI vs Ollama)

Large Ruby Project (8,367 files, 34,761 chunks):

Provider

Time

Speed

Chunks/s

Ollama

21.6 min

6.5 files/s

28 chunks/s

OpenAI (c:3)

13.1 min

10.7 files/s

44 chunks/s

OpenAI saves 8.5 minutes (39% faster) šŸš€


šŸ“– Usage Examples

Index a Codebase

"Index the codebase at /Users/me/Projects/my-app"

Output:

šŸ“Š Pre-flight check for my-app
────────────────────────────────────────────────────────

šŸ“ Scope:
   • Files to index: 2,367
   • Estimated chunks: 8,474
   • Provider: openai

ā±ļø  Estimated time: ~2-3 minutes
   (This is a one-time operation)

šŸ’° Estimated cost: ~$0.0297

šŸ” System checks:
   āœ… Configuration file
   āœ… Vector database connection
   āœ… Embedding provider
   āœ… Disk space

āœ… Ready to index!
   Indexing will run in background - you can continue working.

────────────────────────────────────────────────────────

šŸš€ Indexing started in background!

Job ID: index_1707445123
Estimated time: ~2-3 minutes
Estimated cost: ~$0.0297

šŸ’” You can continue using Claude Code normally.
   Check progress: "Get index status"
   I'll show a summary when indexing completes!

šŸ“ This is a one-time operation. Future updates via git hooks are <10s.

Search Code

"Search for authentication logic in my-app"

Returns:

šŸ” Found 8 results (0.7s):

1. src/services/auth.service.ts:45-67 (score: 0.92)
   export class AuthService {
     async authenticate(credentials: Credentials) {
       // JWT-based authentication
     }
   }

2. src/middleware/auth.middleware.ts:12-28 (score: 0.87)
   export function requireAuth(req, res, next) {
     // Check JWT token
   }

Check Index Status

"Get index status for my-app"

While indexing:

šŸ“Š Indexing in progress (Job #index_1707445123)

Phase: Embedding
Progress: 67.3% (5,700/8,474 chunks)
Speed: 52 chunks/s
ETA: 2.1 minutes

After completion:

āœ… Index Status for my-app

Collection: my_app
Status: Ready
Vectors: 8,346
Dimensions: 1536
Last updated: 2 minutes ago

šŸ† What We've Achieved

Phase 2 Improvements (Complete)

  • āœ… 100% indexing success (was 94%)

  • āœ… 8-10x faster (5.9s vs 42s for small repos)

  • āœ… Auto re-indexing via git hooks

  • āœ… Background operations (non-blocking)

  • āœ… Enhanced search quality (TF-IDF + query expansion)

  • āœ… JavaScript support added

Phase 3.1 Improvements (Complete)

  • āœ… OpenAI provider (2x faster for large repos)

  • āœ… Pre-flight estimates (time/cost upfront)

  • āœ… Better UX (clear guidance, suggestions)

  • āœ… Language filtering (only index supported types)

  • āœ… 26 unit tests (100% coverage on providers)


šŸ› ļø MCP Tools

index_codebase - Index a project

Parameters:

  • path (required): Project root directory

  • background (optional): Run in background (default: true)

Features:

  • Pre-flight estimates (files, time, cost)

  • Health checks before starting

  • Background mode by default

  • Progress tracking

  • Beautiful completion summary

search_code - Semantic search

Parameters:

  • query (required): Natural language search query

  • maxResults (optional): Number of results (default: 10)

  • minScore (optional): Similarity threshold 0-1 (default: 0.7)

  • language (optional): Filter by language

  • pathPattern (optional): Filter by path regex

Features:

  • Hybrid search (vector + keyword)

  • Query expansion (synonyms)

  • TF-IDF keyword extraction

  • Ranked results with scores

get_index_status - Check status

Features:

  • Live progress if indexing

  • Collection statistics if idle

  • Vector count and dimensions

  • Last update timestamp

Additional Tools

  • reindex_changed_files - Incremental update (<10s)

  • enable_git_hooks - Auto re-index on git operations

  • onboard_project - One-command setup

  • reset_state - Emergency cleanup

  • clear_index - Delete all data


⚔ Performance Tips

Optimize for Speed

1. Use OpenAI (2x faster for large repos)

{ "embedding": { "provider": "openai", "concurrency": 3 } }

2. Increase concurrency (if Tier 2+)

{ "embedding": { "concurrency": 5 } } // For Tier 2+ (5,000 RPM)

3. Selective indexing (index only core code)

{
  "indexing": {
    "include": ["app/models/**", "app/services/**"]
  }
}

Optimize for Cost

1. Use Ollama (completely free)

{ "embedding": { "provider": "ollama" } }

2. Selective indexing (fewer files = lower cost)

3. Use incremental updates (git hooks, automatic!)

Optimize for Reliability

1. Lower concurrency (97-98% success)

{ "embedding": { "concurrency": 3 } } // vs 5: more reliable

2. Use Ollama (100% success, no rate limits)


šŸ”§ Troubleshooting

"No files found to index"

Cause: Include patterns don't match any files

Solution:

{
  "indexing": {
    "include": ["**/*.ts", "**/*.rb"], // Match all supported files
    "exclude": ["node_modules/**"]
  }
}

"Vector database not accessible"

Cause: Milvus not running

Solution:

# Check if running
curl http://localhost:19530/healthz

# Start if needed
docker run -d -p 19530:19530 milvusdb/milvus:latest

"Embedding provider not accessible"

For Ollama:

# Check if running
curl http://localhost:11434/api/tags

# Start if needed
ollama serve

For OpenAI:

# Check API key is set
echo $OPENAI_API_KEY

# Set if missing
export OPENAI_API_KEY="sk-..."

Rate Limiting (OpenAI)

Symptom: Many retry messages, <95% success rate

Solution: Reduce concurrency

{
  "embedding": {
    "concurrency": 2, // Down from 3 or 5
    "batchSize": 64 // Down from 128
  }
}

Slow Indexing

Cause: Large file count or conservative settings

Solutions:

  1. Selective indexing - index only core directories

  2. Increase concurrency - if no rate limits

  3. Use OpenAI - 2x faster than Ollama

  4. Exclude more - skip tests, docs, generated code


šŸŽ“ Advanced Usage

Incremental Re-Indexing

Automatic (Recommended):

"Enable git hooks for my-project"

Git hooks auto-update index on:

  • Branch switches (<10s)

  • Pull/merge operations (<10s)

  • New commits (<10s)

Manual:

"Re-index changed files in my-project"

Multi-Project Setup

Index multiple projects independently:

# Project 1
cd /path/to/project1
# Create .semantica/config.json with collectionName: "project1"

# Project 2
cd /path/to/project2
# Create .semantica/config.json with collectionName: "project2"

# Index both
"Index the codebase at /path/to/project1"
"Index the codebase at /path/to/project2"

# Search specific project
"Search for auth in project1"

Provider Switching

Switch from Ollama to OpenAI:

  1. Update config:

{
  "embedding": {
    "provider": "openai",
    "dimensions": 1536 // Changed from 768!
  }
}
  1. Clear old index (dimension changed):

"Clear index for my-project"
  1. Re-index:

"Index the codebase at /path/to/my-project"

šŸ“š Documentation

All configuration options are documented in this README. For development guidance, see CLAUDE.md.


šŸ¤ Contributing

Development Setup

git clone <repo-url>
cd semantica-search-mcp
npm install
npm run build

Development Workflow

npm run watch          # Auto-rebuild on changes
npm test              # Run all tests
npm run test:watch    # Watch mode
npm run test:coverage # Coverage report
npm run inspector     # MCP debugging

Code Quality

  • TypeScript: Strict mode enabled

  • Tests: Jest with 80%+ coverage target

  • Linting: Automatic formatting

  • Architecture: Provider pattern for extensibility


šŸ“ˆ Performance Metrics

Indexing Performance (Phase 2 → Phase 3)

Metric

Phase 1

Phase 2

Phase 3 (OpenAI)

Success rate

94%

100%

97-98%

Small repo (50 files)

~42s

5.9s

3.2s

Large repo (8K files)

N/A

N/A

13.1 min

Incremental update

N/A

<10s

<10s

Search Quality

Metric

Target

Achieved

Relevance (top 5)

90%+

92%

Latency

<2s

<1s

"No results" rate

<10%

<5%


šŸ”’ Security & Privacy

Data Handling

Ollama (Local):

  • āœ… 100% local processing

  • āœ… No data leaves your machine

  • āœ… Complete privacy

OpenAI (Cloud):

  • āš ļø Code chunks sent to OpenAI API

  • āš ļø Embeddings only (not searchable by OpenAI)

  • āš ļø Use environment variables for API keys (never commit!)

API Key Management

Never commit API keys:

{
  "openai": {
    "apiKey": "${OPENAI_API_KEY}" // āœ… Environment variable
  }
}

Not this:

{
  "openai": {
    "apiKey": "sk-proj-..." // āŒ NEVER hardcode!
  }
}

šŸŽÆ FAQ

Q: How long does indexing take? A: 3s-15 min depending on size. Small projects (<100 files): <30s. Large projects (5K+ files): 10-15 min. This is one-time - incremental updates are <10s!

Q: How much does OpenAI cost? A: $0.001-$0.20 per project for initial index. Daily updates: <$0.10. Most projects cost less than a coffee! ā˜•

Q: Can I switch between Ollama and OpenAI? A: Yes! Just update config and re-index (dimension change requires clearing old index).

Q: What happens if indexing is interrupted? A: Just re-run. It's a one-time operation, no checkpointing needed for simplicity.

Q: Does it work offline? A: With Ollama: YES (100% local). With OpenAI: NO (requires internet).

Q: How does this compare to Cursor or GitHub Copilot? A: Cursor indexes ~500-2K files in 1-3 min (with caching). We index ALL files (8K+) in 12-13 min. More complete, comparable speed when accounting for coverage.


šŸš€ What's Next

Completed āœ…

  • Phase 1: TypeScript/Ruby, Ollama, Milvus, AST chunking

  • Phase 2: 100% success, auto re-index, JavaScript, performance

  • Phase 3.1: OpenAI provider, UX improvements, testing

In Progress šŸ”„

  • Phase 3.2: Qdrant vector DB provider (lighter alternative)

  • Phase 3.3: Professional documentation

  • Phase 3.4: Release v2.1.0

Future šŸ”®

  • Python, Go, Java language support

  • Embedding cache (50-70% faster re-indexing)

  • BM25 keyword search

  • Web dashboard UI


šŸ“„ License

Private (for now)


šŸ™ Acknowledgments

Built with research from:


Questions or issues? Check the documentation or create an issue.

Ready to get started? Follow the Quick Start guide above! šŸš€

Available Tools

8 tools
clear_indexB

Clear all indexed data from the vector database. This will delete the collection and all vectors.

Inputs: confirm (required).

enable_git_hooksB

Install git hooks for automatic re-indexing on git operations (branch switch, pull, merge). Makes index stay in sync automatically.

Inputs: path (required), hooks.

get_index_statusA

Get the current status of the indexed codebase. Shows LIVE PROGRESS if indexing is running in background, or collection statistics if idle. Use this to monitor long-running indexing jobs.

Inputs: no named parameters.

index_codebaseA

Index a codebase for semantic code search. Runs in BACKGROUND by default - returns immediately and you can check progress with get_index_status. Extracts functions, classes, and modules, generates embeddings, and stores in vector database.

Inputs: path (required), languages, background.

onboard_projectB

Complete onboarding for a new project: auto-detect language, create optimized config, install git hooks, and start initial indexing. One command to set everything up!

Inputs: path (required), enableGitHooks.

reindex_changed_filesA

Incrementally re-index only changed files (fast). Uses Merkle trees to auto-detect changes, or re-indexes specific files if provided. Much faster than full re-index.

Inputs: path (required), files.

reset_stateA

Emergency reset: kills stuck re-index processes, removes stale locks, cleans up state files. Use this to fix issues like stuck indexing, lock conflicts, or corrupted state.

Inputs: path (required).

search_codeA

Search the indexed codebase semantically using natural language. Returns relevant code chunks with similarity scores.

Inputs: query (required), language, minScore, maxResults, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 8 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes (search, status, incremental reindex, hooks, reset, clear). There is mild overlap between onboard_project and index_codebase/enable_git_hooks since onboarding bundles both, and clear_index vs reset_state could be confused (data deletion vs stuck-process cleanup), but descriptions differentiate them well.

    Naming Consistency5/5

    All eight tools use consistent snake_case verb_noun naming (onboard_project, index_codebase, search_code, get_index_status, reindex_changed_files, enable_git_hooks, reset_state, clear_index). No mixing of conventions or casing.

    Tool Count5/5

    Eight tools is well-scoped for a semantic code search server, covering setup, indexing, search, monitoring, and maintenance without redundancy. Every tool earns its place.

    Completeness4/5

    The surface covers the full lifecycle: onboarding, indexing (full and incremental), search, status monitoring, git hooks, reset, and clearing. Minor gaps exist—no config get/update tool despite onboarding creating config, and no way to remove specific files without a full clear.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Semantic code search engine for Claude Code with hybrid search combining vector, FTS, AST graph, and ripgrep regex, with RRF fusion and reranking.
      47 PyPI
      47
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables semantic search over codebases using natural language queries, returning relevant code snippets with source locations. Integrates with Claude Code for automatic codebase exploration.
      1
      35 PyPI
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides Claude Code with local semantic search and indexing of your codebase using AST-aware chunking and hybrid search, enabling deep code understanding without sending data to the cloud.
      108 PyPI
      MIT