Semantica Search MCP
Provides vector storage and similarity search for code embeddings using Milvus as the vector database.
Allows using Ollama as the embedding provider for semantic code search, supporting local, free models like nomic-embed-text.
Allows using OpenAI as the embedding provider for semantic code search, leveraging cloud-based fast models like text-embedding-3-small.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Semantica Search MCP find authentication logic"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Semantica Search MCP
š Semantic code search for Claude Code - Index and search codebases using natural language with AI embeddings
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 filesReal 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 |
|
| How to split code | Use |
|
| Chunking algorithm | Use |
| number | Max tokens per chunk | 250 (optimal for embeddings) |
| string[] | Glob patterns to index |
|
| string[] | Glob patterns to skip |
|
| 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 |
|
| Embedding service | Ollama: free/local, OpenAI: fast/cloud |
| string | Model name |
|
| number | Vector dimensions | 768 (Ollama) or 1536 (OpenAI) |
| number | Chunks per batch | 64-128 (balance speed/memory) |
| 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 |
|
| Vector database | Use |
| string | Collection/index name | Unique per project |
| string | Database host |
|
| number | Database port | 19530 (Milvus default) |
|
| Index algorithm |
|
|
| Distance metric |
|
search - How to Search
Option | Type | Description | Best Practice |
|
| Search algorithm | Use |
| number | Results to return | 10-20 (avoid overwhelm) |
| number | Similarity threshold | 0.5-0.7 (adjust per project) |
| number | Semantic weight (0-1) | 0.7 (favor semantics) |
| 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: ~25sIntegration 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 minutesAfter 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 directorybackground(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 querymaxResults(optional): Number of results (default: 10)minScore(optional): Similarity threshold 0-1 (default: 0.7)language(optional): Filter by languagepathPattern(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 operationsonboard_project- One-command setupreset_state- Emergency cleanupclear_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 reliable2. 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 serveFor 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:
Selective indexing - index only core directories
Increase concurrency - if no rate limits
Use OpenAI - 2x faster than Ollama
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:
Update config:
{
"embedding": {
"provider": "openai",
"dimensions": 1536 // Changed from 768!
}
}Clear old index (dimension changed):
"Clear index for my-project"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 buildDevelopment 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 debuggingCode 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 toolsclear_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
Scored across 8 tools
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.
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.
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.
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
Related MCP Connectors
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Codebase intelligence for AI coding agents: graph, git history, docs, decisions, code health.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceGives Claude semantic search superpowers to find and reuse existing patterns in your codebase.16-
- AlicenseNot gradedqualityDmaintenanceSemantic code search engine for Claude Code with hybrid search combining vector, FTS, AST graph, and ripgrep regex, with RRF fusion and reranking.47 PyPI47MIT
- AlicenseAqualityDmaintenanceEnables semantic search over codebases using natural language queries, returning relevant code snippets with source locations. Integrates with Claude Code for automatic codebase exploration.135 PyPI1MIT
- AlicenseNot gradedqualityDmaintenanceProvides 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 PyPIMIT