Replaced the local embedder and lance bd with hosted and qdrant db

Author: Asaif Ali

.env.example

@@ -13,18 +13,21 @@ OPENAI_BASE_URL=http://litellm:4000/v1
 OPENAI_API_KEY=
 OLLAMA_MODEL_ID=
 OLLAMA_HOST=http://host.docker.internal:11434
-OLLAMA_EMBEDDER_ID=
 VLLM_BASE_URL=http://host.docker.internal:8000/v1
-VLLM_EMBEDDING_BASE_URL=http://host.docker.internal:8000/v1
 VLLM_CHAT_MODEL_ID=
-VLLM_EMBED_MODEL_ID=
 VLLM_API_KEY=
 GOOGLE_API_KEY=
 HUGGINGFACE_API_KEY=
 HUGGINGFACE_MODEL_ID=
 
 # Embeddings
-EMBED_MODEL_TYPE=fastembed
+QDRANT_CLOUD_INFERENCE=true
+QDRANT_URL=
+QDRANT_API_KEY=
+QDRANT_COLLECTION_PREFIX=legacylens
+QDRANT_DENSE_MODEL=sentence-transformers/all-MiniLM-L6-v2
+QDRANT_SPARSE_MODEL=qdrant/bm25
+QDRANT_DENSE_DIMENSIONS=384
 
 # Database
 DATABASE_URL=

agent_service/app/application/agents/conversion/conversion_tools.py

@@ -53,6 +53,11 @@
 logging.basicConfig(level=logging.INFO)
 _conversion_step_start_sent: set = set()
 
+def _ensure_qdrant_kb_ready() -> None:
+    if kb.source_knowledge is None or kb.target_knowledge is None:
+        kb.init_knowledge_bases()
+
+
 _folder_goals_repo: Optional[IFolderStructureGoalsRepository] = None
 _json_artifact_repo: Optional[IJsonArtifactRepository] = None
 __all__=[

agent_service/app/application/agents/knowledge_base/knowledge_base_agent.py

@@ -1,31 +1,15 @@
-from agno.knowledge.knowledge import Knowledge
-from agno.vectordb.lancedb import LanceDb, SearchType
-from agno.db.sqlite import SqliteDb
-from app.infrastructure.agents_backend.model_provider import model_embedder
-from app.infrastructure.utils.file_utils import get_migration_directory
-
-source_knowledge: Knowledge = None
-target_knowledge: Knowledge = None
-
-def init_knowledge_bases() -> None:
-    global source_knowledge, target_knowledge
-    base = get_migration_directory("", "")
-    base.mkdir(parents=True, exist_ok=True)
-    source_knowledge = Knowledge(
-        contents_db=SqliteDb(db_file=str(base / "source_knowledge.db")),
-        vector_db=LanceDb(
-            uri=str(base / "lancedb"),
-            table_name="source_table",
-            search_type=SearchType.hybrid,
-            embedder=model_embedder,
-        ),
-    )
-    target_knowledge = Knowledge(
-        contents_db=SqliteDb(db_file=str(base / "target_knowledge.db")),
-        vector_db=LanceDb(
-            uri=str(base / "lancedb"),
-            table_name="target_table",
-            search_type=SearchType.hybrid,
-            embedder=model_embedder,
-        ),
-    )
+from app.infrastructure.agents_backend.qdrant_knowledge import QdrantKnowledgeBase, _collection_name
+
+source_knowledge: QdrantKnowledgeBase | None = None
+target_knowledge: QdrantKnowledgeBase | None = None
+
+
+def init_knowledge_bases() -> None:
+    global source_knowledge, target_knowledge
+    source_knowledge = QdrantKnowledgeBase(_collection_name("source"))
+    target_knowledge = QdrantKnowledgeBase(_collection_name("target"))
+
+# Legacy agent_setup imports this name, even though the current KB work is
+# performed through the workflow/tool layer. Keep the symbol to preserve the
+# public import contract without adding another local vector-store object.
+kb_agent = None

agent_service/app/application/agents/knowledge_base/knowledge_base_tools.py

@@ -1,5 +1,4 @@
 import os
-import lancedb
 import logging
 import json
 from typing import Optional, Any, Tuple
@@ -25,6 +24,11 @@
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
 
+def _ensure_qdrant_kb_ready() -> None:
+    if kb.source_knowledge is None or kb.target_knowledge is None:
+        kb.init_knowledge_bases()
+
+
 _kb_event_helper = MigrationEventHelper(
     agent_name="knowledge_base",
     event_name="knowledge_base_started",
@@ -50,6 +54,7 @@ def _get_json_artifact_repo() -> IJsonArtifactRepository:
     return _json_artifact_repo
 
 def load_json_to_knowledge(step_input: StepInput) -> StepOutput:
+    _ensure_qdrant_kb_ready()
     """Load data from a JSON file and add it to the knowledge base."""
     try:
         migration_dir = get_migration_directory("", "")

agent_service/app/application/agents/planning/planning_tools.py

@@ -39,7 +39,6 @@
     get_folder_structure_goals_repository,
 )
 from app.infrastructure.utils.enums.migration_event import MigrationEvent
-from app.infrastructure.agents_backend.model_provider import model_embedder
 from app.infrastructure.utils.Constants.agent_event import AgentEventMessages
 from app.infrastructure.utils.Agent_helpers.planning_helper import *
 from app.infrastructure.utils.token_tracker import track_tokens
@@ -64,6 +63,11 @@
 MODEL_TYPE = os.getenv("MODEL_TYPE", "OpenAI")
 PLANNING_LLM_TIMEOUT_SEC = int(os.getenv("PLANNING_LLM_TIMEOUT_SEC", "180"))
 
+def _ensure_qdrant_kb_ready() -> None:
+    if kb.source_knowledge is None or kb.target_knowledge is None:
+        kb.init_knowledge_bases()
+
+
 _file_mapping_repo: Optional[IFileMappingRepository] = None
 _folder_goals_repo: Optional[IFolderStructureGoalsRepository] = None
 _json_artifact_repo: Optional[IJsonArtifactRepository] = None
@@ -204,6 +208,7 @@ def _get_migration_scan_repo() -> IMigrationScanResultRepository:
 
 
 def get_symbol_module_meta(step_input: StepInput) -> StepOutput:
+    _ensure_qdrant_kb_ready()
     """Fetch all symbols and modules from Knowledge Base"""
      # ── Skip if plan already exists ───────────────────────────────────────
     existing = _load_existing_plan()
@@ -330,6 +335,7 @@ def get_symbol_module_meta(step_input: StepInput) -> StepOutput:
 )
 
 def generate_dependency_plan(step_input: StepInput) -> StepOutput:
+    _ensure_qdrant_kb_ready()
     """
     Reads source symbols and dependencies from step output (get_symbol_module_meta),
     calls dependency_agent to predict the target dependency file,
@@ -794,6 +800,7 @@ def generate_symbols_transformation(step_input: StepInput) -> StepOutput:
     return StepOutput(content={"transformations": transformations, "naming": all_naming})
 
 def generate_migration_plan(step_input: StepInput) -> StepOutput:
+    _ensure_qdrant_kb_ready()
     """
     Step 3: pure-Python plan assembly — no LLM call.
     """

agent_service/app/infrastructure/agents_backend/model_provider.py

@@ -7,12 +7,6 @@
 from agno.models.openai import OpenAIChat
 from app.infrastructure.utils.llm_gateway_context import get_llm_gateway_token
 from agno.models.huggingface import HuggingFace
-from agno.knowledge.embedder.openai import OpenAIEmbedder
-from agno.knowledge.embedder.google import GeminiEmbedder
-from agno.knowledge.embedder.ollama import OllamaEmbedder
-from agno.knowledge.embedder.fastembed import FastEmbedEmbedder
-import hashlib
-import math
 
 # from agno.models.vllm import VLLM
 from openai import AsyncOpenAI, OpenAI
@@ -30,58 +24,10 @@
 OPENAI_BASE_URL = os.getenv("LLM_BASE_URL") or os.getenv("OPENAI_BASE_URL")
 LLM_GATEWAY_URL = os.getenv("LLM_GATEWAY_URL", "https://portfolio-llm-gateway.onrender.com/v1").strip()
 LLM_GATEWAY_TIMEOUT = float(os.getenv("LLM_GATEWAY_TIMEOUT", "180"))
-EMBED_MODEL_TYPE = os.getenv("EMBED_MODEL_TYPE", "fastembed").strip().lower()
-EMBED_DIMENSIONS = int(os.getenv("EMBED_DIMENSIONS", "384"))
-EMBEDDING_BASE_URL = os.getenv("EMBEDDING_BASE_URL")
 VLLM_BASE_URL = os.getenv("VLLM_BASE_URL")
 VLLM_CHAT_MODEL_ID = os.getenv("VLLM_CHAT_MODEL_ID")
-VLLM_EMBED_MODEL_ID = os.getenv("VLLM_EMBED_MODEL_ID")
-VLLM_EMBEDDING_BASE_URL = os.getenv("VLLM_EMBEDDING_BASE_URL")
 VLLM_API_KEY = os.getenv("VLLM_API_KEY") or "local"
 # --------------------------------------------------
-# Embedding: Local vLLM
-# --------------------------------------------------
-class VLLMEmbedder:
-    """Custom embedder for vLLM OpenAI-compatible embedding endpoint"""
-    def __init__(self, base_url: str, model: str):
-        logger.info("🚀 Initializing VLLMEmbedder")
-        self.client = OpenAI(
-            base_url=base_url,
-            api_key=VLLM_API_KEY
-        )
-        self.model = model
-        # Detect embedding dimension
-        test = self.client.embeddings.create(
-            model=self.model,
-            input="test"
-        )
-        self.dimensions = len(test.data[0].embedding)
-        logger.info(f"✅ Embedding dimension detected: {self.dimensions}")
-    def embed_documents(self, texts):
-        logger.info(f"📥 Embedding documents | count={len(texts)}")
-        response = self.client.embeddings.create(
-            model=self.model,
-            input=texts
-        )
-        return [d.embedding for d in response.data]
-    def embed_query(self, text):
-        logger.debug(f"🔍 Embedding query")
-        response = self.client.embeddings.create(
-            model=self.model,
-            input=text
-        )
-        return response.data[0].embedding
-    # AGNO compatibility
-    def get_embedding(self, text):
-        return self.embed_query(text)
-    def get_embedding_and_usage(self, text):
-        embedding = self.embed_query(text)
-        usage = {
-            "prompt_tokens": 0,
-            "total_tokens": 0
-        }
-        return embedding, usage
-# --------------------------------------------------
 # Message Normalization (vLLM compatibility)
 # --------------------------------------------------
 def normalize_messages(messages):
@@ -179,117 +125,59 @@ def get_async_client(self):
         return super().get_async_client()
 
 
-class LowMemoryHashEmbedder:
-    """Dependency-free fallback embedder for small Render instances.
-
-    Produces deterministic, normalized vectors using hashed token/character
-    features. It avoids loading an ONNX embedding model into the service.
-    For this demo-oriented deployment, LanceDB can still perform vector/
-    lexical retrieval without the memory spike caused by FastEmbed startup.
-    """
-
-    def __init__(self, dimensions: int = 384):
-        self.id = "portfolio-hash-embedder"
-        self.dimensions = dimensions
-
-    @staticmethod
-    def _tokens(text: str):
-        text = str(text or "").lower()
-        tokens = []
-        cur = []
-        for ch in text:
-            if ch.isalnum() or ch == "_":
-                cur.append(ch)
-            elif cur:
-                tokens.append("".join(cur))
-                cur = []
-        if cur:
-            tokens.append("".join(cur))
-        return tokens
-
-    def get_embedding(self, text):
-        vec = [0.0] * self.dimensions
-        tokens = self._tokens(text)
-        if not tokens:
-            return vec
-        for token in tokens:
-            for feature in (token, token[:3], token[-3:]):
-                digest = hashlib.blake2b(feature.encode("utf-8"), digest_size=8).digest()
-                idx = int.from_bytes(digest, "little") % self.dimensions
-                sign = 1.0 if (digest[0] & 1) else -1.0
-                vec[idx] += sign
-        norm = math.sqrt(sum(x * x for x in vec)) or 1.0
-        return [x / norm for x in vec]
-
-    def get_embedding_and_usage(self, text):
-        return self.get_embedding(text), {"prompt_tokens": 0, "total_tokens": 0}
-
-    def embed_documents(self, texts):
-        return [self.get_embedding(t) for t in texts]
-
-
-def create_embedder():
-    if EMBED_MODEL_TYPE in {"hash", "low_memory", "low-memory"}:
-        logger.warning("Using low-memory deterministic embeddings for constrained deployment")
-        return LowMemoryHashEmbedder(dimensions=EMBED_DIMENSIONS)
-    return FastEmbedEmbedder(id=os.getenv("FASTEMBED_MODEL", "BAAI/bge-small-en-v1.5"), dimensions=EMBED_DIMENSIONS)
 
 # --------------------------------------------------
 # Model Factory
 # --------------------------------------------------
-def create_model_and_embedder():
-    """Factory to initialize model + embedder based on MODEL_TYPE"""
+def create_model():
+    """Initialize only the chat model. KB embeddings live in Qdrant Cloud."""
     if MODEL_TYPE == "OpenAI":
         model = GatewayAwareOpenAIChat(
             id=OPENAI_MODEL_ID,
             api_key=os.getenv("OPENAI_API_KEY"),
             base_url=OPENAI_BASE_URL,
-            temperature=0.1
+            temperature=0.1,
         )
-        embedder = create_embedder()
-        logger.info("Using OpenAI-compatible model with constrained local embeddings")
+        logger.info("Using OpenAI-compatible model with request-scoped gateway support")
     elif MODEL_TYPE == "VLLM":
         if not VLLM_CHAT_MODEL_ID or not VLLM_BASE_URL:
             raise ValueError("VLLM config missing")
         model = VLLMCompatibleOpenAIChat(
             id=VLLM_CHAT_MODEL_ID,
             base_url=VLLM_BASE_URL,
             api_key=VLLM_API_KEY,
-            temperature=0.1
+            temperature=0.1,
         )
-        embedder = create_embedder()
-        logger.info(f"✅ Using vLLM model: {VLLM_CHAT_MODEL_ID}")
+        logger.info("Using vLLM model: %s", VLLM_CHAT_MODEL_ID)
     elif MODEL_TYPE == "Gemini":
         model = Gemini(
             id=os.getenv("GEMINI_MODEL_ID"),
             api_key=os.getenv("GOOGLE_API_KEY"),
-            temperature=0.1
+            temperature=0.1,
         )
-        embedder = create_embedder()
-        logger.info("✅ Using Gemini model")
+        logger.info("Using Gemini model")
     elif MODEL_TYPE == "Ollama":
         model = Ollama(
             id=os.getenv("OLLAMA_MODEL_ID"),
             host=os.getenv("OLLAMA_HOST"),
             supports_native_structured_outputs=True,
             supports_json_schema_outputs=True,
-            options={"temperature": 0.1, "num_ctx": 256000}
+            options={"temperature": 0.1, "num_ctx": 256000},
         )
-        embedder = FastEmbedEmbedder()
-        logger.info("✅ Using Ollama model")
+        logger.info("Using Ollama model")
     elif MODEL_TYPE == "HuggingFace":
         model = HuggingFace(
             id=os.getenv("HUGGINGFACE_MODEL_ID"),
             api_key=os.getenv("HUGGINGFACE_API_KEY"),
             supports_native_structured_outputs=True,
             supports_json_schema_outputs=True,
         )
-        embedder = create_embedder()
-        logger.info("✅ Using configured local embeddings")
+        logger.info("Using configured HuggingFace chat model")
     else:
         raise ValueError(f"Unsupported MODEL_TYPE: {MODEL_TYPE}")
-    return model, embedder
-# --------------------------------------------------
-# Initialize
-# --------------------------------------------------
-model, model_embedder = create_model_and_embedder()
+    return model
+
+
+model = create_model()
+# Backward-compatibility alias only. No local embedding model is instantiated.
+model_embedder = None