DeepRepo - Local RAG Engine

A production-grade Python library for performing RAG (Retrieval Augmented Generation) on local codebases with multiple AI provider support.

Features

• Raw Python Implementation: No heavy frameworks (LangChain/LlamaIndex), no external Vector DBs
• Multiple AI Providers: Supports Ollama (local), HuggingFace, OpenAI, Anthropic, and Gemini
• MCP Server Support: Integrate with Cursor, Claude Desktop, Antigravity, and other MCP clients
• Decorator-Based Plugin System: Easy provider registration and extensibility
• Vector Store: NumPy-powered cosine similarity with JSON persistence
• RESTful API: FastAPI service for easy integration
• Docker Ready: Full containerization for deployment

Quick Start

Installation

cd deeprepo_core
pip install -e .

See INSTALLATION.md for detailed setup instructions for each provider.

Basic Usage

from deeprepo import DeepRepoClient

# Initialize with Ollama (FREE, local) - same provider for both embeddings and LLM
client = DeepRepoClient(provider_name="ollama")

# Or use different providers for embeddings and LLM
# Example: OpenAI for embeddings, Anthropic for LLM
client = DeepRepoClient(
    embedding_provider_name="openai",
    llm_provider_name="anthropic"
)

# Ingest documents
result = client.ingest("/path/to/your/code")
print(f"Ingested {result['chunks_processed']} chunks")

# Query with RAG
response = client.query("How does authentication work?")
print(response['answer'])
print(f"Sources: {response['sources']}")

Supported AI Providers

| Provider | Cost | Speed | Best For | |----------|------|-------|----------| | Ollama | FREE | Fast | Local development, privacy, offline work | | HuggingFace | FREE* | Medium | Cloud-based, no local setup | | OpenAI | Paid | Very Fast | Production, best quality | | Anthropic | Paid | Very Fast | Production, excellent reasoning | | Gemini | FREE* | Medium | Testing, Google ecosystem |

*Free tier with rate limits

Provider Examples

# Same provider for both embeddings and LLM
# Ollama (Recommended - FREE and unlimited)
client = DeepRepoClient(provider_name="ollama")

# HuggingFace (FREE tier)
client = DeepRepoClient(provider_name="huggingface")

# OpenAI (Paid, best quality)
client = DeepRepoClient(provider_name="openai")

# Anthropic (Paid, excellent reasoning)
# Note: Anthropic doesn't have embeddings API, so use with another provider
client = DeepRepoClient(
    embedding_provider_name="openai",  # Use OpenAI for embeddings
    llm_provider_name="anthropic"     # Use Anthropic for LLM
)

# Gemini (Free tier, limited)
client = DeepRepoClient(provider_name="gemini")

# Mix and match providers
# Example: Use free HuggingFace for embeddings, paid OpenAI for LLM
client = DeepRepoClient(
    embedding_provider_name="huggingface",
    llm_provider_name="openai"
)

Architecture

deeprepo_core/
├── src/deeprepo/
│   ├── client.py       # Main facade
│   ├── storage.py      # Vector store (JSON + NumPy)
│   ├── ingestion.py    # File scanning & chunking
│   ├── interfaces.py   # Abstract base classes
│   ├── registry.py     # Decorator-based registry
│   ├── mcp/            # MCP server for AI assistants
│   │   ├── server.py       # FastMCP server
│   │   └── README.md       # MCP documentation
│   └── providers/
│       ├── ollama_v.py      # Ollama (local, FREE)
│       ├── huggingface_v.py # HuggingFace (cloud, FREE)
│       ├── openai_v.py      # OpenAI (paid)
│       ├── anthropic_v.py   # Anthropic (paid)
│       └── gemini_v.py      # Gemini (free tier)

Design Patterns

• Repository Pattern: VectorStore decouples storage from application logic
• Strategy Pattern: LLMProvider and EmbeddingProvider abstract interfaces
• Registry Pattern: @register_llm decorator for dynamic provider discovery
• Singleton Pattern: FastAPI lifespan loads client once at startup

... View full README on GitHub