Sync from GitHub via hub-sync

README.md

@@ -23,8 +23,8 @@ FastAPI backend for Code Compass, a personal full-stack RAG project that indexes
 
 - Clone a public GitHub repository into temporary storage
 - Filter and chunk source files for retrieval
-- Generate embeddings and store chunks in Qdrant
-- Maintain lightweight repository and session metadata in SQLite
+- Generate embeddings and store chunks in Chroma DB
+- Maintain lightweight repository and session metadata in memory
 - Run indexing as a background task
 - Retrieve evidence with semantic search, lexical search, fusion, and reranking
 - Generate answers from the selected context and return citations to the UI
@@ -45,21 +45,17 @@ Production is configured for lower-cost hosting:
 - `EMBEDDING_PROVIDER=local`
 - Groq-hosted Llama for answer generation
 - Local sentence-transformer embeddings for retrieval
-- Qdrant Cloud for vector storage
+- Chroma DB for vector storage
 
-## Qdrant Keepalive
+## Chroma Storage
 
-The backend starts a lightweight Qdrant keepalive scheduler when `QDRANT_URL` is configured. It calls the configured collection every 12 hours by default so a free-tier Qdrant cluster does not become inactive while the backend process is running.
+The backend uses Chroma DB for vector storage in both local development and production. By default it stores the collection under `./data/chroma`, and you can point it somewhere else with `CHROMA_PATH`.
 
 Configuration:
 
-- `QDRANT_URL`
-- `QDRANT_API_KEY`
-- `QDRANT_COLLECTION=repo_qa_chunks`
-- `QDRANT_KEEPALIVE_ENABLED=true`
-- `QDRANT_KEEPALIVE_INTERVAL_SECONDS=43200`
-
-The main repository also includes a GitHub Actions keepalive workflow for cases where the backend host is asleep.
+- `CHROMA_PATH=./data/chroma`
+- `CHROMA_COLLECTION=repo_qa_chunks`
+- `CHROMA_UPSERT_BATCH_SIZE=64`
 
 ## Metrics
 

requirements.txt

@@ -1,6 +1,5 @@
 fastapi==0.109.2
 uvicorn[standard]==0.27.1
-sqlalchemy==2.0.25
 pydantic==2.6.1
 python-dotenv==1.0.1
 
@@ -11,7 +10,7 @@ google-genai==1.12.1
 httpx==0.28.1
 numpy==1.26.4
 rank-bm25==0.2.2
-qdrant-client==1.15.1
+chromadb>=0.5.23
 sentence-transformers==2.7.0
 einops==0.8.1
 tree-sitter==0.21.3

server_app.py

@@ -8,7 +8,6 @@ from pydantic import BaseModel, Field, HttpUrl
 from dotenv import load_dotenv
 
 from src.bedrock_claude import BedrockTransientError, is_bedrock_retryable_error
-from src.qdrant_keepalive import QdrantKeepAliveScheduler
 from src.rag_system import CodebaseRAGSystem
 
 load_dotenv(Path(__file__).with_name(".env"))
@@ -35,7 +34,6 @@ app.add_middleware(
 )
 
 rag_system: Optional[CodebaseRAGSystem] = None
-qdrant_keepalive: Optional[QdrantKeepAliveScheduler] = None
 
 
 class RepoIndexRequest(BaseModel):
@@ -62,17 +60,15 @@ def require_session_id(x_session_id: Optional[str] = Header(None, alias="X-Sessi
 
 @app.on_event("startup")
 def startup():
-    global qdrant_keepalive, rag_system
+    global rag_system
     Path("./data").mkdir(exist_ok=True)
     rag_system = CodebaseRAGSystem()
-    qdrant_keepalive = QdrantKeepAliveScheduler(rag_system.vector_store)
-    qdrant_keepalive.start()
 
 
 @app.on_event("shutdown")
 def shutdown():
-    if qdrant_keepalive is not None:
-        qdrant_keepalive.stop()
+    if rag_system is not None:
+        rag_system.vector_store.save()
 
 
 @app.get("/")

src/__init__.py

@@ -7,14 +7,14 @@ from .embeddings import EmbeddingGenerator
 from .hybrid_search import HybridSearchEngine
 from .rag_system import CodebaseRAGSystem
 from .repo_fetcher import RepoFetcher
-from .vector_store import QdrantVectorStore
+from .vector_store import ChromaVectorStore
 
 __version__ = "2.0.0"
 __all__ = [
     "CodeParser",
     "CodebaseRAGSystem",
     "EmbeddingGenerator",
-    "QdrantVectorStore",
+    "ChromaVectorStore",
     "HybridSearchEngine",
     "RepoFetcher",
 ]

src/database.py

@@ -1,143 +0,0 @@
-import os
-from datetime import datetime
-from pathlib import Path
-
-from sqlalchemy import (
-    JSON,
-    Column,
-    DateTime,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    Text,
-    create_engine,
-    inspect,
-    text,
-)
-from sqlalchemy.orm import declarative_base, relationship, sessionmaker
-
-Base = declarative_base()
-_ENGINE_CACHE = {}
-_SESSION_FACTORY_CACHE = {}
-SERVER_DIR = Path(__file__).resolve().parents[1]
-
-
-class Repository(Base):
-    __tablename__ = "repositories"
-
-    id = Column(Integer, primary_key=True)
-    github_url = Column(String(1024), nullable=False, unique=True)
-    source_url = Column(String(1024))
-    session_key = Column(String(255), index=True)
-    session_expires_at = Column(DateTime)
-    owner = Column(String(255), nullable=False)
-    name = Column(String(255), nullable=False)
-    branch = Column(String(255), nullable=False, default="main")
-    local_path = Column(String(1024))
-    status = Column(String(64), nullable=False, default="queued")
-    error_message = Column(Text)
-    file_count = Column(Integer, nullable=False, default=0)
-    chunk_count = Column(Integer, nullable=False, default=0)
-    indexed_at = Column(DateTime)
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-
-    chunks = relationship(
-        "CodeChunk", back_populates="repository", cascade="all, delete-orphan"
-    )
-    chat_turns = relationship(
-        "ChatTurn", back_populates="repository", cascade="all, delete-orphan"
-    )
-
-
-class CodeChunk(Base):
-    __tablename__ = "code_chunks"
-
-    id = Column(Integer, primary_key=True)
-    repository_id = Column(Integer, ForeignKey("repositories.id"), nullable=False)
-    file_path = Column(String(1024), nullable=False)
-    language = Column(String(64), nullable=False)
-    symbol_name = Column(String(255))
-    symbol_type = Column(String(128), nullable=False, default="chunk")
-    line_start = Column(Integer, nullable=False)
-    line_end = Column(Integer, nullable=False)
-    signature = Column(Text)
-    content = Column(Text, nullable=False)
-    searchable_text = Column(Text, nullable=False)
-    metadata_json = Column(JSON, nullable=False, default=dict)
-    embedding_id = Column(Integer)
-    rerank_score = Column(Float)
-    created_at = Column(DateTime, default=datetime.utcnow)
-
-    repository = relationship("Repository", back_populates="chunks")
-
-
-class ChatTurn(Base):
-    __tablename__ = "chat_turns"
-
-    id = Column(Integer, primary_key=True)
-    repository_id = Column(Integer, ForeignKey("repositories.id"), nullable=False)
-    role = Column(String(32), nullable=False)
-    content = Column(Text, nullable=False)
-    answer_json = Column(JSON)
-    created_at = Column(DateTime, default=datetime.utcnow)
-
-    repository = relationship("Repository", back_populates="chat_turns")
-
-
-def init_db(database_url: str = None):
-    if database_url is None:
-        database_url = os.getenv("DATABASE_URL", "sqlite:///./codebase_rag.db")
-
-    database_url = resolve_database_url(database_url)
-    if database_url in _ENGINE_CACHE:
-        return _ENGINE_CACHE[database_url], _SESSION_FACTORY_CACHE[database_url]
-
-    connect_args = {"check_same_thread": False} if database_url.startswith("sqlite") else {}
-    engine = create_engine(database_url, echo=False, connect_args=connect_args)
-    Base.metadata.create_all(engine)
-    _ensure_runtime_columns(engine)
-    session_local = sessionmaker(bind=engine)
-    _ENGINE_CACHE[database_url] = engine
-    _SESSION_FACTORY_CACHE[database_url] = session_local
-    return engine, session_local
-
-
-def resolve_database_url(database_url: str) -> str:
-    if not database_url.startswith("sqlite:///"):
-        return database_url
-
-    sqlite_path = database_url.removeprefix("sqlite:///")
-    if sqlite_path == ":memory:":
-        return database_url
-
-    path = Path(sqlite_path)
-    if not path.is_absolute():
-        path = SERVER_DIR / path
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.touch(exist_ok=True)
-    return f"sqlite:///{path.resolve()}"
-
-
-def _ensure_runtime_columns(engine):
-    inspector = inspect(engine)
-    if "repositories" not in inspector.get_table_names():
-        return
-
-    existing = {column["name"] for column in inspector.get_columns("repositories")}
-    alterations = {
-        "source_url": "ALTER TABLE repositories ADD COLUMN source_url VARCHAR(1024)",
-        "session_key": "ALTER TABLE repositories ADD COLUMN session_key VARCHAR(255)",
-        "session_expires_at": "ALTER TABLE repositories ADD COLUMN session_expires_at DATETIME",
-    }
-
-    with engine.begin() as connection:
-        for column_name, statement in alterations.items():
-            if column_name not in existing:
-                connection.execute(text(statement))
-
-
-def get_db_session(database_url: str = None):
-    _, session_local = init_db(database_url)
-    return session_local()

src/qdrant_keepalive.py

@@ -1,83 +0,0 @@
-import os
-import threading
-from typing import Optional
-
-from src.vector_store import QdrantVectorStore
-
-
-class QdrantKeepAliveScheduler:
-    def __init__(self, vector_store: QdrantVectorStore):
-        self.vector_store = vector_store
-        self.interval_seconds = self._interval_seconds()
-        self.run_on_start = self._env_flag("QDRANT_KEEPALIVE_RUN_ON_START", True)
-        self.keepalive_enabled = self._env_flag("QDRANT_KEEPALIVE_ENABLED", True)
-        self.enabled = self.keepalive_enabled and self.vector_store.is_remote()
-        self._stop_event = threading.Event()
-        self._thread: Optional[threading.Thread] = None
-
-    def start(self):
-        if not self.enabled:
-            reason = (
-                "disabled by QDRANT_KEEPALIVE_ENABLED"
-                if not self.keepalive_enabled
-                else "set QDRANT_URL to enable remote Qdrant pings"
-            )
-            print(
-                f"[qdrant-keepalive] Disabled; {reason}",
-                flush=True,
-            )
-            return
-        if self._thread and self._thread.is_alive():
-            return
-
-        self._stop_event.clear()
-        self._thread = threading.Thread(
-            target=self._run,
-            name="qdrant-keepalive",
-            daemon=True,
-        )
-        self._thread.start()
-        print(
-            f"[qdrant-keepalive] Started interval_seconds={self.interval_seconds}",
-            flush=True,
-        )
-
-    def stop(self):
-        self._stop_event.set()
-        if self._thread and self._thread.is_alive():
-            self._thread.join(timeout=5)
-        self._thread = None
-
-    def _run(self):
-        if self.run_on_start:
-            self._ping()
-
-        while not self._stop_event.wait(self.interval_seconds):
-            self._ping()
-
-    def _ping(self):
-        try:
-            stats = self.vector_store.keep_alive()
-            print(
-                "[qdrant-keepalive] Ping succeeded "
-                f"collection={stats['collection_name']} "
-                f"points={stats['total_vectors']}",
-                flush=True,
-            )
-        except Exception as exc:
-            print(f"[qdrant-keepalive] Ping failed: {exc}", flush=True)
-
-    @staticmethod
-    def _env_flag(name: str, default: bool) -> bool:
-        value = os.getenv(name)
-        if value is None:
-            return default
-        return value.strip().lower() not in {"0", "false", "no", "off"}
-
-    @staticmethod
-    def _interval_seconds() -> int:
-        value = os.getenv("QDRANT_KEEPALIVE_INTERVAL_SECONDS", "43200")
-        try:
-            return max(60, int(value))
-        except ValueError:
-            return 43200

src/rag_system.py

@@ -1,44 +1,57 @@
 import os
 import re
+from dataclasses import dataclass, field
 from datetime import datetime, timedelta
+from threading import RLock
 from typing import Dict, List, Optional
 
 from openai import OpenAI
 
 from src.code_parser import CodeParser
 from src.bedrock_claude import create_bedrock_runtime_client, generate_bedrock_claude_text
-from src.database import Repository, get_db_session, init_db, resolve_database_url
 from src.embeddings import EmbeddingGenerator
 from src.hybrid_search import HybridSearchEngine
 from src.repo_fetcher import RepoFetcher
-from src.vector_store import QdrantVectorStore
+from src.vector_store import ChromaVectorStore
 
 
 class SessionCancelledError(RuntimeError):
     pass
 
 
+@dataclass
+class Repository:
+    id: int
+    github_url: str
+    source_url: str
+    session_key: str
+    session_expires_at: datetime
+    owner: str
+    name: str
+    branch: str = "main"
+    local_path: Optional[str] = None
+    status: str = "queued"
+    error_message: Optional[str] = None
+    file_count: int = 0
+    chunk_count: int = 0
+    indexed_at: Optional[datetime] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    updated_at: datetime = field(default_factory=datetime.utcnow)
+
+
 class CodebaseRAGSystem:
     def __init__(
         self,
-        database_url: str = None,
         repo_dir: str = None,
         index_path: str = None,
     ):
-        self.database_url = database_url or os.getenv(
-            "DATABASE_URL", "sqlite:///./codebase_rag.db"
-        )
-        self.database_url = resolve_database_url(self.database_url)
-        init_db(self.database_url)
-        print(f"[database] Using database_url={self.database_url}", flush=True)
-
         self.repo_fetcher = RepoFetcher(base_dir=repo_dir)
         self.parser = CodeParser()
         self.embedder = EmbeddingGenerator()
-        self.vector_store = QdrantVectorStore(
+        self.vector_store = ChromaVectorStore(
             embedding_dim=self.embedder.get_embedding_dim(),
-            index_path=index_path or "./data/faiss/codebase_index",
-            persist=False,
+            index_path=index_path or "./data/chroma",
+            persist=True,
         )
         self.hybrid_search = HybridSearchEngine(
             reranker_model=os.getenv(
@@ -51,34 +64,35 @@ class CodebaseRAGSystem:
         self.llm_model = ""
         self._configure_llm()
         self.session_ttl_minutes = int(os.getenv("SESSION_TTL_MINUTES", "120"))
+        self.repo_lock = RLock()
+        self.repositories: Dict[int, Repository] = {}
+        self.repository_registry: Dict[str, int] = {}
+        self.next_repo_id = 1
         self.indexing_progress: Dict[int, dict] = {}
         self.repo_chunks: Dict[int, List[dict]] = {}
         self.cancelled_repo_ids = set()
         self.rebuild_indexes()
 
     def rebuild_indexes(self):
-        session = get_db_session(self.database_url)
-        try:
+        with self.repo_lock:
             self.vector_store.clear()
+            self.repositories.clear()
+            self.repository_registry.clear()
+            self.next_repo_id = 1
             self.repo_chunks.clear()
             self.indexing_progress.clear()
             self.cancelled_repo_ids.clear()
-            repos = session.query(Repository).all()
-            self._delete_repositories(session, repos, track_cancellation=False)
-            self.cancelled_repo_ids.clear()
-            session.commit()
-        finally:
-            session.close()
 
     def create_or_reset_repository(self, github_url: str, session_key: str) -> Repository:
         info = self.repo_fetcher.parse_github_url(github_url)
         registry_key = self._build_registry_key(session_key, github_url)
-        session = get_db_session(self.database_url)
-        try:
-            self._cleanup_expired_sessions(session)
-            repo = session.query(Repository).filter_by(github_url=registry_key).first()
+        with self.repo_lock:
+            self._cleanup_expired_sessions()
+            repo_id = self.repository_registry.get(registry_key)
+            repo = self.repositories.get(repo_id) if repo_id else None
             if repo is None:
                 repo = Repository(
+                    id=self.next_repo_id,
                     github_url=registry_key,
                     source_url=github_url,
                     session_key=session_key,
@@ -88,8 +102,9 @@ class CodebaseRAGSystem:
                     branch=info["branch"],
                     status="queued",
                 )
-                session.add(repo)
-                session.flush()
+                self.next_repo_id += 1
+                self.repositories[repo.id] = repo
+                self.repository_registry[registry_key] = repo.id
                 self.cancelled_repo_ids.discard(repo.id)
             else:
                 repo.source_url = github_url
@@ -103,37 +118,39 @@ class CodebaseRAGSystem:
                 repo.file_count = 0
                 repo.chunk_count = 0
                 repo.indexed_at = None
+                self._mark_repo_updated(repo)
                 self.cancelled_repo_ids.discard(repo.id)
                 self.hybrid_search.remove_repository(repo.id)
                 self.vector_store.remove_repository(repo.id)
                 self.repo_chunks.pop(repo.id, None)
 
-            session.commit()
-            session.refresh(repo)
             return repo
-        finally:
-            session.close()
 
     def index_repository(self, repo_id: int):
-        session = get_db_session(self.database_url)
+        clone_info = None
         try:
-            self._cleanup_expired_sessions(session)
-            repo = session.query(Repository).filter_by(id=repo_id).first()
-            if repo is None:
-                raise ValueError("Repository not found")
-            self._ensure_repo_not_cancelled(repo.id)
-            print(f"[indexing] Starting repository index repo_id={repo.id}", flush=True)
+            with self.repo_lock:
+                self._cleanup_expired_sessions()
+                repo = self.repositories.get(repo_id)
+                if repo is None:
+                    raise ValueError("Repository not found")
+                self._ensure_repo_not_cancelled(repo.id)
+                print(f"[indexing] Starting repository index repo_id={repo.id}", flush=True)
+
+                repo.status = "indexing"
+                repo.error_message = None
+                repo.session_expires_at = self._session_expiry()
+                self._mark_repo_updated(repo)
 
-            repo.status = "indexing"
-            repo.error_message = None
-            repo.session_expires_at = self._session_expiry()
-            session.commit()
             self._set_progress(repo.id, phase="cloning", message="Cloning repository")
 
             clone_info = self.repo_fetcher.clone_repository(repo.source_url or repo.github_url)
             self._ensure_repo_not_cancelled(repo.id)
-            repo.local_path = None
-            repo.branch = clone_info["branch"]
+            with self.repo_lock:
+                self._ensure_repo_still_exists(repo.id)
+                repo.branch = clone_info["branch"]
+                repo.local_path = None
+                self._mark_repo_updated(repo)
             print(
                 f"[indexing] Repository cloned repo_id={repo.id} branch={repo.branch} "
                 f"path={clone_info['local_path']}",
@@ -250,82 +267,74 @@ class CodebaseRAGSystem:
                 }
                 created_rows.append(row)
 
-            repo.status = "indexed"
-            repo.file_count = file_count
-            repo.chunk_count = len(created_rows)
-            repo.indexed_at = datetime.utcnow()
-            repo.session_expires_at = self._session_expiry()
-            self._ensure_repo_still_exists(session, repo.id)
-            self._ensure_repo_not_cancelled(repo.id)
-            session.commit()
-
             serialized = [self._serialize_chunk(chunk) for chunk in created_rows]
-            self.repo_chunks[repo.id] = serialized
+            with self.repo_lock:
+                self._ensure_repo_still_exists(repo.id)
+                self._ensure_repo_not_cancelled(repo.id)
+                repo.status = "indexed"
+                repo.file_count = file_count
+                repo.chunk_count = len(created_rows)
+                repo.indexed_at = datetime.utcnow()
+                repo.session_expires_at = self._session_expiry()
+                self._mark_repo_updated(repo)
+                self.repo_chunks[repo.id] = serialized
             self.vector_store.save()
-            self.indexing_progress.pop(repo.id, None)
-            self.cancelled_repo_ids.discard(repo.id)
+            with self.repo_lock:
+                self.indexing_progress.pop(repo.id, None)
+                self.cancelled_repo_ids.discard(repo.id)
             self.repo_fetcher.cleanup_repository(clone_info["local_path"])
             print(f"[indexing] Repository index complete repo_id={repo.id}", flush=True)
         except Exception as exc:
             print(f"[indexing] Repository index failed repo_id={repo_id} error={exc}", flush=True)
-            session.rollback()
             self.vector_store.remove_repository(repo_id)
-            self.repo_chunks.pop(repo_id, None)
             self.hybrid_search.remove_repository(repo_id)
-            repo = session.query(Repository).filter_by(id=repo_id).first()
-            if repo:
-                if repo_id in self.cancelled_repo_ids:
-                    session.delete(repo)
-                else:
-                    repo.status = "failed"
-                    repo.error_message = str(exc)
-                session.commit()
+            with self.repo_lock:
+                self.repo_chunks.pop(repo_id, None)
+                repo = self.repositories.get(repo_id)
+                if repo:
+                    if repo_id in self.cancelled_repo_ids:
+                        self._delete_repositories([repo], track_cancellation=False)
+                    else:
+                        repo.status = "failed"
+                        repo.error_message = str(exc)
+                        self._mark_repo_updated(repo)
             try:
-                if "clone_info" in locals():
+                if clone_info:
                     self.repo_fetcher.cleanup_repository(clone_info["local_path"])
             except Exception:
                 pass
-            self.indexing_progress.pop(repo_id, None)
+            with self.repo_lock:
+                self.indexing_progress.pop(repo_id, None)
             if isinstance(exc, SessionCancelledError):
                 return
             raise
-        finally:
-            session.close()
 
     def list_repositories(self) -> List[dict]:
         raise NotImplementedError
 
     def list_repositories_for_session(self, session_key: str) -> List[dict]:
-        session = get_db_session(self.database_url)
-        try:
-            self._cleanup_expired_sessions(session)
-            repos = (
-                session.query(Repository)
-                .filter_by(session_key=session_key)
-                .order_by(Repository.updated_at.desc())
-                .all()
-            )
-            self._touch_session(session, session_key)
+        with self.repo_lock:
+            self._cleanup_expired_sessions()
+            repos = [
+                repo
+                for repo in self.repositories.values()
+                if repo.session_key == session_key
+            ]
+            repos.sort(key=lambda repo: repo.updated_at, reverse=True)
+            self._touch_session(session_key)
             return [self._serialize_repo(repo) for repo in repos]
-        finally:
-            session.close()
 
     def get_repository(self, repo_id: int) -> Optional[dict]:
         raise NotImplementedError
 
     def get_repository_for_session(self, repo_id: int, session_key: str) -> Optional[dict]:
-        session = get_db_session(self.database_url)
-        try:
-            self._cleanup_expired_sessions(session)
-            repo = (
-                session.query(Repository)
-                .filter_by(id=repo_id, session_key=session_key)
-                .first()
-            )
-            self._touch_session(session, session_key)
+        with self.repo_lock:
+            self._cleanup_expired_sessions()
+            repo = self.repositories.get(repo_id)
+            if repo and repo.session_key != session_key:
+                repo = None
+            self._touch_session(session_key)
             return self._serialize_repo(repo) if repo else None
-        finally:
-            session.close()
 
     def answer_question(
         self,
@@ -335,96 +344,92 @@ class CodebaseRAGSystem:
         top_k: int = 8,
         history=None,
     ) -> dict:
-        session = get_db_session(self.database_url)
-        try:
-            self._cleanup_expired_sessions(session)
-            repo = (
-                session.query(Repository)
-                .filter_by(id=repo_id, session_key=session_key)
-                .first()
-            )
+        with self.repo_lock:
+            self._cleanup_expired_sessions()
+            repo = self.repositories.get(repo_id)
+            if repo and repo.session_key != session_key:
+                repo = None
             if repo is None:
                 raise ValueError("Repository not found")
             if repo.status != "indexed":
                 raise ValueError("Repository is not ready for questions yet")
             if repo_id not in self.repo_chunks:
                 raise ValueError("Session cache expired. Re-index the repository and try again.")
-            self._touch_session(session, session_key)
+            repo_chunks = list(self.repo_chunks[repo_id])
+            self._touch_session(session_key)
 
-            normalized_history = self._normalize_history(history or [])
-            question_intent = self._question_intent(question)
-            deep_search_intents = {
-                "api",
-                "implementation",
-                "cross_file",
-                "error_handling",
-                "setup",
-                "tests",
-            }
-            deep_multiplier = int(os.getenv("RAG_DEEP_SEARCH_MULTIPLIER", "8"))
-            shallow_multiplier = int(os.getenv("RAG_SEARCH_MULTIPLIER", "4"))
-            search_depth = (
-                top_k * deep_multiplier
-                if question_intent in deep_search_intents
-                else top_k * shallow_multiplier
-            )
-            search_depth = max(top_k, min(search_depth, 120))
+        normalized_history = self._normalize_history(history or [])
+        question_intent = self._question_intent(question)
+        deep_search_intents = {
+            "api",
+            "implementation",
+            "cross_file",
+            "error_handling",
+            "setup",
+            "tests",
+        }
+        deep_multiplier = int(os.getenv("RAG_DEEP_SEARCH_MULTIPLIER", "8"))
+        shallow_multiplier = int(os.getenv("RAG_SEARCH_MULTIPLIER", "4"))
+        search_depth = (
+            top_k * deep_multiplier
+            if question_intent in deep_search_intents
+            else top_k * shallow_multiplier
+        )
+        search_depth = max(top_k, min(search_depth, 120))
 
-            retrieval_query = self._build_retrieval_query(question, normalized_history)
-            query_embedding = self.embedder.embed_text(retrieval_query)
+        retrieval_query = self._build_retrieval_query(question, normalized_history)
+        query_embedding = self.embedder.embed_text(retrieval_query)
 
-            semantic_hits = []
-            for score, meta in self.vector_store.search(query_embedding, k=search_depth, repo_filter=repo_id):
-                serialized = dict(meta)
-                serialized["semantic_score"] = score
-                semantic_hits.append(serialized)
+        semantic_hits = []
+        for score, meta in self.vector_store.search(query_embedding, k=search_depth, repo_filter=repo_id):
+            serialized = dict(meta)
+            serialized["semantic_score"] = score
+            semantic_hits.append(serialized)
 
-            lexical_hits = self.hybrid_search.bm25_search(
-                self.repo_chunks[repo_id],
-                retrieval_query,
-                top_k=search_depth,
-            )
-            semantic_hits = self.hybrid_search.normalize_semantic_results(semantic_hits)
-            fused = self.hybrid_search.reciprocal_rank_fusion(lexical_hits, semantic_hits, top_k=search_depth)
-
-            path_hits = self._path_intent_search(
-                self.repo_chunks[repo_id],
-                question,
-                retrieval_query,
-                top_k=search_depth,
-            )
-            fused = self._merge_ranked_candidates(fused, path_hits, top_k=search_depth)
+        lexical_hits = self.hybrid_search.bm25_search(
+            repo_chunks,
+            retrieval_query,
+            top_k=search_depth,
+        )
+        semantic_hits = self.hybrid_search.normalize_semantic_results(semantic_hits)
+        fused = self.hybrid_search.reciprocal_rank_fusion(lexical_hits, semantic_hits, top_k=search_depth)
+
+        path_hits = self._path_intent_search(
+            repo_chunks,
+            question,
+            retrieval_query,
+            top_k=search_depth,
+        )
+        fused = self._merge_ranked_candidates(fused, path_hits, top_k=search_depth)
 
-            rerank_query = retrieval_query if question_intent in deep_search_intents else question
+        rerank_query = retrieval_query if question_intent in deep_search_intents else question
 
-            # FIX: rerank to a small candidate pool first (20), then let
-            # _prioritize_results and _select_answer_sources trim to final top_k.
-            # Previously rerank was called with search_depth (up to 120), meaning
-            # the LLM received far too many chunks and faithfulness dropped.
-            rerank_pool = min(search_depth, 20)
-            reranked = self.hybrid_search.rerank(rerank_query, fused, top_k=rerank_pool)
+        # FIX: rerank to a small candidate pool first (20), then let
+        # _prioritize_results and _select_answer_sources trim to final top_k.
+        # Previously rerank was called with search_depth (up to 120), meaning
+        # the LLM received far too many chunks and faithfulness dropped.
+        rerank_pool = min(search_depth, 20)
+        reranked = self.hybrid_search.rerank(rerank_query, fused, top_k=rerank_pool)
 
-            reranked = self._prioritize_results(question, retrieval_query, reranked, top_k=top_k)
+        reranked = self._prioritize_results(question, retrieval_query, reranked, top_k=top_k)
 
-            # FIX: cap final sources at 5 instead of top_k (8).
-            # 5 sources × 1500 chars = ~7500 chars context, which the LLM handles well.
-            # 8 sources × 2500 chars = ~20000 chars, which causes lost-in-the-middle issues.
-            final_top_k = min(top_k, 5)
-            reranked = self._select_answer_sources(question, reranked, top_k=final_top_k)
+        # FIX: cap final sources at 5 instead of top_k (8).
+        # 5 sources × 1500 chars = ~7500 chars context, which the LLM handles well.
+        # 8 sources × 2500 chars = ~20000 chars, which causes lost-in-the-middle issues.
+        final_top_k = min(top_k, 5)
+        reranked = self._select_answer_sources(question, reranked, top_k=final_top_k)
 
-            answer = self._generate_answer(repo, question, reranked, normalized_history)
-            return answer
-        finally:
-            session.close()
+        answer = self._generate_answer(repo, question, reranked, normalized_history)
+        return answer
 
     def end_session(self, session_key: str):
-        session = get_db_session(self.database_url)
-        try:
-            repos = session.query(Repository).filter_by(session_key=session_key).all()
-            self._delete_repositories(session, repos)
-            session.commit()
-        finally:
-            session.close()
+        with self.repo_lock:
+            repos = [
+                repo
+                for repo in self.repositories.values()
+                if repo.session_key == session_key
+            ]
+            self._delete_repositories(repos)
 
 
     def _generate_answer(
@@ -800,35 +805,33 @@ Do not leave the answer unfinished.
         return payload
 
     def _set_progress(self, repo_id: int, **progress):
-        self.indexing_progress[repo_id] = {
-            **self.indexing_progress.get(repo_id, {}),
-            **progress,
-            "updated_at": datetime.utcnow().isoformat(),
-        }
+        with self.repo_lock:
+            self.indexing_progress[repo_id] = {
+                **self.indexing_progress.get(repo_id, {}),
+                **progress,
+                "updated_at": datetime.utcnow().isoformat(),
+            }
 
-    def _touch_session(self, session, session_key: str):
+    def _touch_session(self, session_key: str):
         expiry = self._session_expiry()
-        repos = session.query(Repository).filter_by(session_key=session_key).all()
-        for repo in repos:
-            repo.session_expires_at = expiry
-        session.commit()
+        for repo in self.repositories.values():
+            if repo.session_key == session_key:
+                repo.session_expires_at = expiry
+                self._mark_repo_updated(repo)
 
-    def _cleanup_expired_sessions(self, session):
+    def _cleanup_expired_sessions(self):
         now = datetime.utcnow()
-        expired = (
-            session.query(Repository)
-            .filter(Repository.session_expires_at.is_not(None))
-            .filter(Repository.session_expires_at < now)
-            .all()
-        )
+        expired = [
+            repo
+            for repo in self.repositories.values()
+            if repo.session_expires_at is not None and repo.session_expires_at < now
+        ]
         if not expired:
             return
-        self._delete_repositories(session, expired)
-        session.commit()
+        self._delete_repositories(expired)
 
     def _delete_repositories(
         self,
-        session,
         repos: List[Repository],
         track_cancellation: bool = True,
     ):
@@ -840,13 +843,18 @@ Do not leave the answer unfinished.
             self.vector_store.remove_repository(repo_id)
             self.repo_chunks.pop(repo_id, None)
             self.indexing_progress.pop(repo_id, None)
-        for repo in repos:
-            session.delete(repo)
+            repo = self.repositories.pop(repo_id, None)
+            if repo:
+                self.repository_registry.pop(repo.github_url, None)
 
     def _ensure_repo_not_cancelled(self, repo_id: int):
         if repo_id in self.cancelled_repo_ids:
             raise SessionCancelledError("Session ended before indexing completed.")
 
+    @staticmethod
+    def _mark_repo_updated(repo: Repository):
+        repo.updated_at = datetime.utcnow()
+
     def _build_retrieval_query(self, question: str, history: List[dict]) -> str:
         normalized = " ".join(question.strip().split())
         if self._is_repo_overview_question(normalized):
@@ -1660,9 +1668,8 @@ Do not leave the answer unfinished.
                 lines.append(f"{role}: {content[:400]}")
         return "\n".join(lines) if lines else "None"
 
-    @staticmethod
-    def _ensure_repo_still_exists(session, repo_id: int):
-        if session.query(Repository.id).filter_by(id=repo_id).first() is None:
+    def _ensure_repo_still_exists(self, repo_id: int):
+        if repo_id not in self.repositories:
             raise RuntimeError("Repository was removed before indexing completed.")
 
     def _session_expiry(self) -> datetime:

src/vector_store.py

@@ -1,60 +1,44 @@
 import os
+from pathlib import Path
 from typing import List, Optional, Tuple
 from uuid import uuid4
 
 import numpy as np
-from qdrant_client import QdrantClient, models
+from chromadb import Client
+from chromadb.config import Settings
 
 
-class QdrantVectorStore:
-    def __init__(self, embedding_dim: int, index_path: str = None, persist: bool = False):
+class ChromaVectorStore:
+    def __init__(self, embedding_dim: int, index_path: str = None, persist: bool = True):
         self.embedding_dim = embedding_dim
-        self.collection_name = os.getenv("QDRANT_COLLECTION", "repo_qa_chunks")
-        self.upsert_batch_size = max(1, int(os.getenv("QDRANT_UPSERT_BATCH_SIZE", "64")))
-        self.qdrant_url = self._clean_env("QDRANT_URL")
-        self.qdrant_api_key = self._clean_env("QDRANT_API_KEY")
-        self.timeout = int(os.getenv("QDRANT_TIMEOUT_SECONDS", "120"))
+        self.collection_name = os.getenv("CHROMA_COLLECTION", "repo_qa_chunks")
+        self.upsert_batch_size = max(1, int(os.getenv("CHROMA_UPSERT_BATCH_SIZE", "64")))
+        self.persist_path = os.getenv("CHROMA_PATH", index_path or "./data/chroma")
+        self.persist = persist
         self.client = self._create_client()
-        self._ensure_collection()
+        self.collection = self._ensure_collection()
 
     def _create_client(self):
-        if self.qdrant_url:
-            return QdrantClient(
-                url=self.qdrant_url,
-                api_key=self.qdrant_api_key,
-                timeout=self.timeout,
-                check_compatibility=False,
+        if self.persist:
+            Path(self.persist_path).mkdir(parents=True, exist_ok=True)
+            return Client(
+                Settings(
+                    is_persistent=True,
+                    persist_directory=self.persist_path,
+                    anonymized_telemetry=False,
+                )
             )
-        return QdrantClient(":memory:")
 
-    @staticmethod
-    def _clean_env(name: str) -> Optional[str]:
-        value = os.getenv(name)
-        if value is None:
-            return None
-        cleaned = value.strip()
-        return cleaned or None
+        return Client(Settings(anonymized_telemetry=False))
 
     def _ensure_collection(self):
-        if not self.client.collection_exists(self.collection_name):
-            self.client.create_collection(
-                collection_name=self.collection_name,
-                vectors_config=models.VectorParams(
-                    size=self.embedding_dim,
-                    distance=models.Distance.COSINE,
-                ),
-            )
-        self._ensure_payload_indexes()
-
-    def _ensure_payload_indexes(self):
-        self.client.create_payload_index(
-            collection_name=self.collection_name,
-            field_name="repository_id",
-            field_schema=models.PayloadSchemaType.INTEGER,
-            wait=True,
+        return self.client.get_or_create_collection(
+            name=self.collection_name,
+            embedding_function=None,
+            metadata={"hnsw:space": "cosine"},
         )
 
-    def add_embeddings(self, embeddings: np.ndarray, metadata: List[dict]) -> List[int]:
+    def add_embeddings(self, embeddings: np.ndarray, metadata: List[dict]) -> List[str]:
         if embeddings.size == 0:
             return []
 
@@ -63,31 +47,33 @@ class QdrantVectorStore:
             embeddings = embeddings.reshape(1, -1)
 
         ids = [uuid4().hex for _ in metadata]
-        points = []
-        for idx, meta, embedding in zip(ids, metadata, embeddings):
-            payload = dict(meta)
-            payload["id"] = idx
-            points.append(
-                models.PointStruct(
-                    id=idx,
-                    vector=embedding.tolist(),
-                    payload=payload,
-                )
-            )
-        total_points = len(points)
+        total_points = len(ids)
+
         for start in range(0, total_points, self.upsert_batch_size):
-            batch = points[start : start + self.upsert_batch_size]
+            end = start + self.upsert_batch_size
+            batch_ids = ids[start:end]
+            batch_embeddings = embeddings[start:end].tolist()
+            batch_metadata = []
+            batch_documents = []
+
+            for idx, meta in zip(batch_ids, metadata[start:end]):
+                payload = self._sanitize_metadata(meta)
+                payload["id"] = idx
+                batch_metadata.append(payload)
+                batch_documents.append(str(meta.get("content") or ""))
+
             batch_number = (start // self.upsert_batch_size) + 1
             total_batches = (total_points + self.upsert_batch_size - 1) // self.upsert_batch_size
             print(
-                f"[qdrant] Upserting batch {batch_number}/{total_batches} "
-                f"points={len(batch)} progress={start}/{total_points}",
+                f"[chroma] Adding batch {batch_number}/{total_batches} "
+                f"points={len(batch_ids)} progress={start}/{total_points}",
                 flush=True,
             )
-            self.client.upsert(
-                collection_name=self.collection_name,
-                wait=True,
-                points=batch,
+            self.collection.add(
+                ids=batch_ids,
+                embeddings=batch_embeddings,
+                metadatas=batch_metadata,
+                documents=batch_documents,
             )
 
         return ids
@@ -102,67 +88,75 @@ class QdrantVectorStore:
             query_embedding = query_embedding.reshape(1, -1)
         query_embedding = query_embedding.astype("float32")
 
-        query_filter = None
-        if repo_filter is not None:
-            query_filter = models.Filter(
-                must=[
-                    models.FieldCondition(
-                        key="repository_id",
-                        match=models.MatchValue(value=repo_filter),
-                    )
-                ]
-            )
-
-        hits = self.client.search(
-            collection_name=self.collection_name,
-            query_vector=query_embedding[0].tolist(),
-            query_filter=query_filter,
-            limit=k,
+        where = {"repository_id": repo_filter} if repo_filter is not None else None
+        results = self.collection.query(
+            query_embeddings=[query_embedding[0].tolist()],
+            n_results=k,
+            where=where,
+            include=["documents", "metadatas", "distances"],
         )
 
-        return [(float(hit.score), dict(hit.payload or {})) for hit in hits]
+        ids = (results.get("ids") or [[]])[0]
+        documents = (results.get("documents") or [[]])[0]
+        metadatas = (results.get("metadatas") or [[]])[0]
+        distances = (results.get("distances") or [[]])[0]
+
+        hits = []
+        for idx, document, meta, distance in zip(ids, documents, metadatas, distances):
+            payload = dict(meta or {})
+            payload["id"] = payload.get("id") or idx
+            payload["content"] = document or ""
+            hits.append((self._distance_to_score(distance), payload))
+        return hits
 
     def remove_repository(self, repo_id: int):
-        self.client.delete(
-            collection_name=self.collection_name,
-            wait=True,
-            points_selector=models.FilterSelector(
-                filter=models.Filter(
-                    must=[
-                        models.FieldCondition(
-                            key="repository_id",
-                            match=models.MatchValue(value=repo_id),
-                        )
-                    ]
-                )
-            ),
-        )
+        self.collection.delete(where={"repository_id": repo_id})
 
     def clear(self):
-        if self.client.collection_exists(self.collection_name):
-            self.client.delete_collection(self.collection_name)
-        self._ensure_collection()
+        try:
+            self.client.delete_collection(name=self.collection_name)
+        except Exception:
+            pass
+        self.collection = self._ensure_collection()
 
     def save(self):
-        return None
+        persist = getattr(self.client, "persist", None)
+        if callable(persist):
+            persist()
 
     def load(self):
-        self._ensure_collection()
-
-    def is_remote(self) -> bool:
-        return self.qdrant_url is not None
+        self.collection = self._ensure_collection()
 
     def keep_alive(self) -> dict:
-        info = self.client.get_collection(self.collection_name)
-        return {
-            "total_vectors": info.points_count or 0,
-            "collection_name": self.collection_name,
-        }
+        heartbeat = getattr(self.client, "heartbeat", None)
+        if callable(heartbeat):
+            heartbeat()
+        return self.get_stats()
 
     def get_stats(self) -> dict:
-        info = self.client.get_collection(self.collection_name)
         return {
-            "total_vectors": info.points_count or 0,
+            "total_vectors": self.collection.count(),
             "embedding_dim": self.embedding_dim,
             "collection_name": self.collection_name,
+            "persist_path": self.persist_path if self.persist else None,
         }
+
+    @staticmethod
+    def _sanitize_metadata(meta: dict) -> dict:
+        sanitized = {}
+        for key, value in meta.items():
+            if key == "content":
+                continue
+            if value is None:
+                sanitized[key] = ""
+            elif isinstance(value, (str, int, float, bool)):
+                sanitized[key] = value
+            else:
+                sanitized[key] = str(value)
+        return sanitized
+
+    @staticmethod
+    def _distance_to_score(distance: float) -> float:
+        if distance is None:
+            return 0.0
+        return max(0.0, min(1.0, 1.0 - float(distance)))