Refactor code structure for improved readability and maintainability

app/core/llm_factory.py

@@ -31,23 +31,23 @@ DEFAULT_EMBEDDING_MODEL = "nvidia/nv-embedqa-e5-v5"
 AGENT_CONFIGS: dict[TeamRole, dict[str, Any]] = {
     # Phase 1
     TeamRole.PROJECT_REFINER: {"temperature": 0.3, "max_tokens": 2048},
-    TeamRole.PRODUCT_OWNER: {"temperature": 0.5, "max_tokens": 2048},
+    TeamRole.PRODUCT_OWNER: {"temperature": 0.5, "max_tokens": 4096},
     # Phase 2
     TeamRole.BUSINESS_ANALYST: {"temperature": 0.3, "max_tokens": 3072},
     TeamRole.SOLUTION_ARCHITECT: {"temperature": 0.4, "max_tokens": 3072},
-    TeamRole.DATA_ARCHITECT: {"temperature": 0.3, "max_tokens": 2048},
+    TeamRole.DATA_ARCHITECT: {"temperature": 0.3, "max_tokens": 4096},
     TeamRole.SECURITY_ANALYST: {"temperature": 0.2, "max_tokens": 2048},
     # Phase 3
     TeamRole.UX_DESIGNER: {"temperature": 0.8, "max_tokens": 2048},
     TeamRole.API_DESIGNER: {"temperature": 0.2, "max_tokens": 4096},
-    TeamRole.QA_STRATEGIST: {"temperature": 0.3, "max_tokens": 2048},
+    TeamRole.QA_STRATEGIST: {"temperature": 0.3, "max_tokens": 4096},
     TeamRole.DEVOPS_ARCHITECT: {"temperature": 0.3, "max_tokens": 2048},
     # Phase 4
     TeamRole.ENVIRONMENT_ENGINEER: {"temperature": 0.3, "max_tokens": 2048},
     TeamRole.TECHNICAL_WRITER: {"temperature": 0.5, "max_tokens": 3072},
     # Phase 5 / Judge
     TeamRole.SPEC_COORDINATOR: {"temperature": 0.3, "max_tokens": 4096},
-    TeamRole.JUDGE: {"temperature": 0.1, "max_tokens": 1024},
+    TeamRole.JUDGE: {"temperature": 0.1, "max_tokens": 2048},
 }
 
 # Default configuration for unknown roles

app/core/mongodb_rag.py

@@ -0,0 +1,378 @@
+"""
+MongoDB Atlas Vector Search RAG Service with agent-specific collections.
+
+Each agent role has its own collection with specialized examples:
+- Product Owner: PRDs, user stories, acceptance criteria
+- Business Analyst: BRDs, process flows
+- Solution Architect: System designs, ADRs
+- etc.
+
+This enables more relevant RAG retrieval per agent specialty.
+"""
+
+import os
+from typing import Any
+
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.vectorstores import VectorStore
+
+from .llm_factory import get_embeddings_model
+from .observability import get_logger
+from .schemas import TeamRole
+
+logger = get_logger("mongodb_rag")
+
+
+# Mapping from TeamRole to MongoDB collection name
+# Coordinator roles (PROJECT_REFINER, SPEC_COORDINATOR, JUDGE) don't need RAG
+# as they synthesize from other agent outputs
+ROLE_COLLECTION_MAP: dict[TeamRole, str | None] = {
+    TeamRole.PRODUCT_OWNER: "rag_product_owner",
+    TeamRole.BUSINESS_ANALYST: "rag_business_analyst",
+    TeamRole.SOLUTION_ARCHITECT: "rag_solution_architect",
+    TeamRole.DATA_ARCHITECT: "rag_data_architect",
+    TeamRole.SECURITY_ANALYST: "rag_security_analyst",
+    TeamRole.UX_DESIGNER: "rag_ux_designer",
+    TeamRole.API_DESIGNER: "rag_api_designer",
+    TeamRole.QA_STRATEGIST: "rag_qa_strategist",
+    TeamRole.DEVOPS_ARCHITECT: "rag_devops_architect",
+    TeamRole.ENVIRONMENT_ENGINEER: "rag_environment_engineer",
+    TeamRole.TECHNICAL_WRITER: "rag_technical_writer",
+    # Coordinator roles - no RAG needed
+    TeamRole.PROJECT_REFINER: None,
+    TeamRole.SPEC_COORDINATOR: None,
+    TeamRole.JUDGE: None,
+}
+
+# All collection names for setup/seeding scripts
+ALL_RAG_COLLECTIONS = [
+    name for name in ROLE_COLLECTION_MAP.values() if name is not None
+]
+
+
+class MongoDBRAGService:
+    """
+    RAG Service with MongoDB Atlas Vector Search for agent-specific retrieval.
+
+    Features:
+    - Agent-specific collections for specialized examples
+    - Lazy initialization of vector stores
+    - Health check for connection monitoring
+    - Document management (add/delete)
+    """
+
+    def __init__(self):
+        self.embeddings = get_embeddings_model()
+        self._client: Any | None = None  # MongoClient
+        self._db_name: str = os.getenv("MONGODB_DATABASE", "specs_before_code")
+        self._index_name: str = os.getenv("MONGODB_INDEX_NAME", "vector_index")
+        self._vector_stores: dict[TeamRole, VectorStore] = {}
+        self._initialized = False
+        self._initialize_connection()
+
+    def _initialize_connection(self) -> None:
+        """Initialize MongoDB connection."""
+        uri = os.getenv("MONGODB_URI")
+        if not uri:
+            logger.warning("MONGODB_URI not set - MongoDB RAG disabled")
+            return
+
+        try:
+            from pymongo import MongoClient
+
+            self._client = MongoClient(
+                uri,
+                maxPoolSize=10,
+                minPoolSize=2,
+                maxIdleTimeMS=30000,
+                serverSelectionTimeoutMS=5000,
+            )
+            # Verify connection
+            self._client.admin.command("ping")
+            self._initialized = True
+            logger.info(
+                "Connected to MongoDB Atlas",
+                data={"database": self._db_name},
+            )
+        except ImportError:
+            logger.error("pymongo not installed - run: uv add pymongo")
+            self._client = None
+        except Exception as e:
+            logger.error(f"Failed to connect to MongoDB: {e}")
+            self._client = None
+
+    def _get_collection(self, role: TeamRole) -> Any | None:
+        """Get MongoDB collection for a specific agent role."""
+        if not self._client:
+            return None
+
+        collection_name = ROLE_COLLECTION_MAP.get(role)
+        if not collection_name:
+            logger.debug(f"No RAG collection mapped for role: {role.value}")
+            return None
+
+        return self._client[self._db_name][collection_name]
+
+    def _get_vector_store(self, role: TeamRole) -> VectorStore | None:
+        """Get or create vector store for a specific agent role (lazy init)."""
+        # Return cached store if available
+        if role in self._vector_stores:
+            return self._vector_stores[role]
+
+        collection = self._get_collection(role)
+        if collection is None:
+            return None
+
+        try:
+            from langchain_mongodb import MongoDBAtlasVectorSearch
+
+            vector_store = MongoDBAtlasVectorSearch(
+                collection=collection,
+                embedding=self.embeddings,
+                index_name=self._index_name,
+                text_key="content",
+                embedding_key="embedding",
+            )
+
+            self._vector_stores[role] = vector_store
+            logger.debug(f"Initialized vector store for {role.value}")
+            return vector_store
+
+        except ImportError:
+            logger.error(
+                "langchain-mongodb not installed - run: uv add langchain-mongodb"
+            )
+            return None
+        except Exception as e:
+            logger.error(f"Error creating vector store for {role.value}: {e}")
+            return None
+
+    def retrieve(
+        self,
+        query: str,
+        role: TeamRole,
+        k: int = 3,
+    ) -> list[Document]:
+        """
+        Retrieve relevant documents for a specific agent role.
+
+        Args:
+            query: The search query (usually project description or context)
+            role: The agent role to retrieve examples for
+            k: Number of documents to retrieve (default: 3)
+
+        Returns:
+            List of relevant Document objects, empty if no matches or error
+        """
+        vector_store = self._get_vector_store(role)
+        if not vector_store:
+            logger.debug(f"No vector store available for role {role.value}")
+            return []
+
+        try:
+            docs = vector_store.similarity_search(query, k=k)
+            logger.info(
+                f"Retrieved {len(docs)} docs for {role.value}",
+                data={"role": role.value, "count": len(docs)},
+            )
+            return docs
+        except Exception as e:
+            logger.error(f"RAG retrieval error for {role.value}: {e}")
+            return []
+
+    def get_retriever(
+        self,
+        role: TeamRole,
+        k: int = 3,
+        search_type: str = "similarity",
+    ) -> BaseRetriever | None:
+        """
+        Get a LangChain retriever for a specific agent role.
+
+        Useful for LCEL chain composition with RunnablePassthrough.
+
+        Args:
+            role: The agent role for role-specific retrieval
+            k: Number of documents to retrieve
+            search_type: Type of search ("similarity" or "mmr")
+
+        Returns:
+            LangChain BaseRetriever or None if unavailable
+        """
+        vector_store = self._get_vector_store(role)
+        if not vector_store:
+            return None
+
+        return vector_store.as_retriever(
+            search_type=search_type,
+            search_kwargs={"k": k},
+        )
+
+    def format_docs(self, docs: list[Document]) -> str:
+        """
+        Format retrieved documents for prompt injection.
+
+        Args:
+            docs: List of retrieved documents
+
+        Returns:
+            Formatted string with examples, or message if empty
+        """
+        if not docs:
+            return "No relevant examples found in knowledge base."
+
+        formatted = []
+        for i, doc in enumerate(docs, 1):
+            source = doc.metadata.get("source", "Unknown")
+            role = doc.metadata.get("role", "")
+
+            header = f"### Example {i}"
+            if source != "Unknown":
+                header += f" (Source: {source})"
+            if role:
+                header += f" [{role}]"
+
+            formatted.append(f"{header}\n{doc.page_content}")
+
+        return "\n\n---\n\n".join(formatted)
+
+    async def add_documents(
+        self,
+        documents: list[Document],
+        role: TeamRole,
+    ) -> list[str]:
+        """
+        Add documents to an agent's RAG collection.
+
+        Args:
+            documents: Documents to add (will be embedded)
+            role: Target agent role (determines collection)
+
+        Returns:
+            List of inserted document IDs
+
+        Raises:
+            ValueError: If no collection exists for the role
+        """
+        vector_store = self._get_vector_store(role)
+        if not vector_store:
+            raise ValueError(f"No RAG collection for role {role.value}")
+
+        # Add role metadata to all documents
+        for doc in documents:
+            doc.metadata["role"] = role.value
+
+        try:
+            ids = await vector_store.aadd_documents(documents)
+            logger.info(
+                f"Added {len(ids)} documents to {role.value}",
+                data={"role": role.value, "count": len(ids)},
+            )
+            return ids
+        except Exception as e:
+            logger.error(f"Error adding documents for {role.value}: {e}")
+            raise
+
+    async def delete_documents(
+        self,
+        ids: list[str],
+        role: TeamRole,
+    ) -> bool:
+        """
+        Delete documents from an agent's collection by ID.
+
+        Args:
+            ids: Document IDs to delete
+            role: Agent role (determines collection)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        vector_store = self._get_vector_store(role)
+        if not vector_store:
+            return False
+
+        try:
+            if hasattr(vector_store, "adelete"):
+                await vector_store.adelete(ids=ids)
+            elif hasattr(vector_store, "delete"):
+                vector_store.delete(ids=ids)
+            else:
+                logger.warning("Vector store does not support deletion")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting documents for {role.value}: {e}")
+            return False
+
+    def health_check(self) -> dict[str, Any]:
+        """
+        Return health status of MongoDB connection.
+
+        Returns:
+            Dict with status, database name, and collection info
+        """
+        if not self._client:
+            return {
+                "status": "disconnected",
+                "message": "MONGODB_URI not configured or connection failed",
+            }
+
+        try:
+            self._client.admin.command("ping")
+
+            # Get collection stats
+            db = self._client[self._db_name]
+            existing_collections = set(db.list_collection_names())
+            configured_collections = [c for c in ALL_RAG_COLLECTIONS if c]
+
+            return {
+                "status": "connected",
+                "database": self._db_name,
+                "index_name": self._index_name,
+                "configured_collections": configured_collections,
+                "existing_collections": [
+                    c for c in configured_collections if c in existing_collections
+                ],
+                "missing_collections": [
+                    c for c in configured_collections if c not in existing_collections
+                ],
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": str(e),
+            }
+
+    def is_available(self) -> bool:
+        """Check if MongoDB RAG is available and connected."""
+        return self._initialized and self._client is not None
+
+    def get_roles_with_rag(self) -> list[TeamRole]:
+        """Get list of roles that have RAG collections configured."""
+        return [role for role, coll in ROLE_COLLECTION_MAP.items() if coll is not None]
+
+
+# Singleton instance
+_mongodb_rag_service: MongoDBRAGService | None = None
+
+
+def get_mongodb_rag_service() -> MongoDBRAGService:
+    """
+    Get singleton instance of MongoDB RAG service.
+
+    Uses module-level singleton for connection reuse.
+    """
+    global _mongodb_rag_service
+    if _mongodb_rag_service is None:
+        _mongodb_rag_service = MongoDBRAGService()
+    return _mongodb_rag_service
+
+
+def reset_mongodb_rag_service() -> None:
+    """Reset the singleton (useful for testing)."""
+    global _mongodb_rag_service
+    if _mongodb_rag_service and _mongodb_rag_service._client:
+        _mongodb_rag_service._client.close()
+    _mongodb_rag_service = None

app/core/orchestrator.py

@@ -102,40 +102,112 @@ class Orchestrator:
     ) -> AsyncIterator[dict[str, Any]]:
         """
         Run the pipeline with streaming output for each agent.
+
+        Emits SSE events:
+        - status: General status message
+        - context_ready: RAG context has been gathered
+        - agent_start: An agent has started processing
+        - chunk: A chunk of content from streaming
+        - agent_complete: An agent has finished
+        - judge_start: Judge evaluation started
+        - judge_complete: Judge evaluation finished
+        - pipeline_complete: Full pipeline finished with results
+        - error: Error occurred
         """
-        # Build initial context similarly
         initial_context = f"Project Description: {project_request.description}"
 
-        # Gather RAG context first
         yield {"type": "status", "message": "Starting Multi-Agent Pipeline..."}
 
+        query = initial_context
+        docs = self.rag_service.retrieve(query, k=3)
+        retrieval_context = self.rag_service.format_docs(docs)
         yield {
-            "type": "status",
-            "message": "Pipeline execution started. Please wait for agents...",
+            "type": "context_ready",
+            "message": f"Retrieved {len(docs)} context documents",
+            "docs_count": len(docs),
         }
 
-        async for event in self.graph.astream(
-            {
-                "context": initial_context,
-                "retrieval_context": "",
-                "history": [],
-                "outputs": {},
-                "current_role": "",
-                "feedback": "",
-                "retry_count": 0,
-                "judge_results": {},
+        all_outputs: dict[str, str] = {}
+        all_judge_results: dict[str, dict[str, Any]] = {}
+        history: list[AgentResponse] = []
+
+        execution_order = [
+            TeamRole.PROJECT_REFINER,
+            TeamRole.PRODUCT_OWNER,
+            TeamRole.BUSINESS_ANALYST,
+            TeamRole.SOLUTION_ARCHITECT,
+            TeamRole.DATA_ARCHITECT,
+            TeamRole.SECURITY_ANALYST,
+            TeamRole.UX_DESIGNER,
+            TeamRole.API_DESIGNER,
+            TeamRole.QA_STRATEGIST,
+            TeamRole.DEVOPS_ARCHITECT,
+            TeamRole.ENVIRONMENT_ENGINEER,
+            TeamRole.TECHNICAL_WRITER,
+            TeamRole.SPEC_COORDINATOR,
+        ]
+
+        for role in execution_order:
+            yield {"type": "agent_start", "role": role.value}
+
+            deps = AGENT_DEPENDENCIES.get(role, [])
+            filtered_history = []
+
+            if deps == ["*"]:
+                filtered_history = history
+            else:
+                core_roles = [TeamRole.PROJECT_REFINER, TeamRole.PRODUCT_OWNER]
+                allowed_roles = set(
+                    [d.value for d in deps] + [c.value for c in core_roles]
+                )
+                for msg in history:
+                    if msg.role.value in allowed_roles:
+                        filtered_history.append(msg)
+
+            response = await self.agent_system.process_step(
+                role=role,
+                context=initial_context,
+                previous_outputs=filtered_history,
+                feedback="",
+                retrieval_context=retrieval_context,
+            )
+
+            history.append(response)
+            all_outputs[role.value] = response.content
+
+            yield {
+                "type": "agent_complete",
+                "role": role.value,
+                "content_length": len(response.content),
             }
-        ):
-            # Inspect event to see which node finished
-            for key, value in event.items():
-                if key in [r.value for r in TeamRole]:
-                    yield {
-                        "type": "agent_complete",
-                        "role": key,
-                        "content_length": len(value.get("outputs", {}).get(key, "")),
-                    }
-
-        yield {"type": "pipeline_complete", "markdown_outputs": {}, "judge_results": {}}
+
+            if role in self.judged_roles:
+                yield {"type": "judge_start", "role": role.value}
+
+                judge_output = await self.agent_system.evaluate_step(
+                    role=role, content=response.content, context=initial_context
+                )
+
+                all_judge_results[role.value] = {
+                    "is_approved": judge_output.is_approved,
+                    "score": judge_output.score,
+                    "issues_count": len(judge_output.issues),
+                    "recommended_action": judge_output.recommended_action,
+                    "feedback": judge_output.feedback,
+                }
+
+                yield {
+                    "type": "judge_complete",
+                    "role": role.value,
+                    "is_approved": judge_output.is_approved,
+                    "score": judge_output.score,
+                }
+
+        yield {
+            "type": "pipeline_complete",
+            "markdown_outputs": all_outputs,
+            "judge_results": all_judge_results,
+        }
 
     def _build_graph(self):
         graph = StateGraph(AgentState)
@@ -256,11 +328,6 @@ class Orchestrator:
             graph.add_edge(source, judge)
 
             # Determine success destination
-            # If multiple next_nodes, we assume they are handled by a single 'gate' or we fan out.
-            # Here we assume the input `next_nodes` leads to a single logical step (like a Gate)
-            # OR we are just passing the first one if logic dictates.
-            # In our graph, we route to Gates mostly.
-
             success_dest = get_dest_value(next_nodes[0])
 
             graph.add_conditional_edges(

app/core/rag.py

@@ -1,10 +1,14 @@
 """
 RAG (Retrieval-Augmented Generation) Service.
+
+Unified RAG interface with MongoDB Atlas as primary and in-memory fallback.
+Supports both role-specific retrieval (via MongoDB) and generic retrieval.
+
 Features:
-- Pinecone vectorstore for production (with fallback to in-memory)
+- MongoDB Atlas Vector Search for production (agent-specific collections)
+- In-memory vectorstore fallback for local development
 - LangChain Retriever interface for RAG chains
 - Document ingestion from corpus directory
-- Embedding caching via Redis (optional)
 """
 
 import os
@@ -18,95 +22,78 @@ from langchain_core.vectorstores import InMemoryVectorStore, VectorStore
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 
 from .llm_factory import get_embeddings_model
+from .mongodb_rag import MongoDBRAGService, get_mongodb_rag_service
 from .observability import get_logger
+from .schemas import TeamRole
 
 load_dotenv()
 logger = get_logger("rag")
+
 # Define paths
 BASE_DIR = Path(__file__).resolve().parents[2]
 CORPUS_DIR = BASE_DIR / "corpus_rag"
 VECTOR_STORE_PATH = BASE_DIR / "public" / "vector_store"
+
 # Error messages
 ERR_VECTOR_STORE_NOT_INIT = "Vector store not initialized"
 
 
 class RAGService:
     """
-    RAG Service with Pinecone vectorstore integration.
-    Supports:
-    - Pinecone for production (requires PINECONE_API_KEY and PINECONE_INDEX)
-    - In-memory vectorstore for local development
-    - LangChain Retriever interface for LCEL chains
+    Unified RAG Service with MongoDB primary and in-memory fallback.
+
+    Priority order:
+    1. MongoDB Atlas Vector Search (if MONGODB_URI configured)
+    2. In-memory vectorstore (development fallback)
+
+    For role-specific retrieval, use the `role` parameter in retrieve/get_retriever.
+    When role is provided and MongoDB is available, retrieval is from agent-specific
+    collections for more relevant examples.
     """
 
     def __init__(self):
         self.embeddings = get_embeddings_model()
-        self.vector_store: VectorStore | None = None
-        self._initialize_vector_store()
-
-    def _initialize_vector_store(self):
-        """Initialize vectorstore with Pinecone or fallback."""
-        pinecone_api_key = os.getenv("PINECONE_API_KEY")
-        pinecone_index = os.getenv("PINECONE_INDEX")
-        if pinecone_api_key and pinecone_index:
-            self._init_pinecone(pinecone_api_key, pinecone_index)
-        else:
-            self._init_fallback()
-
-    def _init_pinecone(self, api_key: str, index_name: str):
-        """Initialize Pinecone vectorstore."""
-        try:
-            from langchain_pinecone import PineconeVectorStore
-            from pinecone import Pinecone
-
-            logger.info("Initializing Pinecone vectorstore", data={"index": index_name})
-            # Initialize Pinecone client
-            pc = Pinecone(api_key=api_key)
-            # Get the index
-            index = pc.Index(index_name)
-            # Create LangChain vectorstore
-            self.vector_store = PineconeVectorStore(
-                index=index,
-                embedding=self.embeddings,
-                text_key="page_content",
-            )
-            logger.info("Pinecone vectorstore initialized successfully")
-        except ImportError as e:
-            logger.warning(f"Pinecone not installed: {e}. Using fallback.")
-            self._init_fallback()
-        except Exception as e:
-            logger.error(f"Failed to initialize Pinecone: {e}. Using fallback.")
-            self._init_fallback()
-
-    def _init_fallback(self):
-        """Initialize fallback in-memory vectorstore."""
-        logger.info("Using in-memory vectorstore (development mode)")
-        # In-memory store doesn't persist to disk in this simplified version
-        # to avoid dependency on custom pickling logic from rag_simple.
-        # It simply rebuilds from corpus on startup.
-        self._build_vector_store()
-
-    def _build_vector_store(self):
-        """Build vectorstore from corpus documents."""
+        self._mongodb_service: MongoDBRAGService | None = None
+        self._fallback_store: VectorStore | None = None
+        self._initialize()
+
+    def _initialize(self) -> None:
+        """Initialize RAG backends in priority order."""
+        # Try MongoDB first
+        if os.getenv("MONGODB_URI"):
+            self._mongodb_service = get_mongodb_rag_service()
+            if self._mongodb_service.is_available():
+                logger.info("Using MongoDB Atlas for RAG (primary)")
+                # Still initialize fallback for non-role-specific queries
+                self._init_fallback_store()
+                return
+
+        # Fallback to in-memory only
+        logger.info("Using in-memory vector store only (MongoDB unavailable)")
+        self._init_fallback_store()
+
+    def _init_fallback_store(self) -> None:
+        """Initialize fallback in-memory vectorstore from corpus."""
         if not CORPUS_DIR.exists():
             logger.warning(f"Corpus directory not found: {CORPUS_DIR}")
-            self._create_empty_store()
+            self._fallback_store = InMemoryVectorStore(embedding=self.embeddings)
             return
 
-        # Load documents
+        # Load and split documents
         documents = self._load_documents()
-
         if not documents:
-            logger.warning("No documents found to ingest")
-            self._create_empty_store()
+            logger.warning("No documents found for fallback store")
+            self._fallback_store = InMemoryVectorStore(embedding=self.embeddings)
             return
 
-        # Split documents into chunks
         chunks = self._split_documents(documents)
         logger.info(f"Created {len(chunks)} chunks from {len(documents)} documents")
 
-        # Create vector store
-        self._create_store_from_documents(chunks)
+        self._fallback_store = InMemoryVectorStore.from_documents(
+            documents=chunks,
+            embedding=self.embeddings,
+        )
+        logger.info("Fallback in-memory vectorstore initialized")
 
     def _load_documents(self) -> list[Document]:
         """Load documents from corpus directory."""
@@ -139,60 +126,91 @@ class RAGService:
         )
         return text_splitter.split_documents(documents)
 
-    def _create_empty_store(self):
-        """Create an empty in-memory vectorstore."""
-        self.vector_store = InMemoryVectorStore(embedding=self.embeddings)
-        logger.info("Created empty in-memory vectorstore")
+    def retrieve(
+        self,
+        query: str,
+        role: TeamRole | None = None,
+        k: int = 3,
+    ) -> list[Document]:
+        """
+        Retrieve relevant documents for a query.
 
-    def _create_store_from_documents(self, documents: list[Document]):
-        """Create vectorstore from documents."""
-        self.vector_store = InMemoryVectorStore.from_documents(
-            documents=documents,
-            embedding=self.embeddings,
-        )
-        logger.info("Created in-memory vectorstore from documents")
+        Args:
+            query: Search query (project description or context)
+            role: Optional agent role for role-specific retrieval (MongoDB only)
+            k: Number of documents to retrieve
+
+        Returns:
+            List of relevant documents
+        """
+        # Use MongoDB for role-specific retrieval if available
+        if self._mongodb_service and self._mongodb_service.is_available() and role:
+            docs = self._mongodb_service.retrieve(query, role, k)
+            if docs:
+                return docs
+            # Fall through to fallback if no MongoDB results
+
+        # Fallback retrieval
+        if self._fallback_store:
+            try:
+                docs = self._fallback_store.similarity_search(query, k=k)
+                logger.debug(f"Retrieved {len(docs)} documents from fallback store")
+                return docs
+            except Exception as e:
+                logger.error(f"Error during fallback retrieval: {e}")
+                return []
+
+        logger.warning("No vector store available for retrieval")
+        return []
 
     def get_retriever(
         self,
+        role: TeamRole | None = None,
         k: int = 3,
         filter: dict[str, Any] | None = None,
         search_type: str = "similarity",
-    ) -> BaseRetriever:
+    ) -> BaseRetriever | None:
         """
         Get a LangChain Retriever for RAG chains.
-        """
-        if not self.vector_store:
-            raise RuntimeError(ERR_VECTOR_STORE_NOT_INIT)
 
-        search_kwargs = {"k": k}
-        if filter:
-            search_kwargs["filter"] = filter
+        Args:
+            role: Optional agent role for role-specific retrieval
+            k: Number of documents to retrieve
+            filter: Optional filter dict (fallback store only)
+            search_type: "similarity" or "mmr"
 
-        return self.vector_store.as_retriever(
-            search_type=search_type,
-            search_kwargs=search_kwargs,
-        )
-
-    def retrieve(self, query: str, k: int = 3) -> list[Document]:
-        """
-        Retrieve relevant documents for a query.
+        Returns:
+            LangChain BaseRetriever or None
         """
-        if not self.vector_store:
-            logger.warning("Vector store not initialized")
-            return []
-
-        try:
-            docs = self.vector_store.similarity_search(query, k=k)
-            logger.debug(f"Retrieved {len(docs)} documents for query")
-            return docs
-        except Exception as e:
-            logger.error(f"Error during retrieval: {e}")
-            return []
+        # Use MongoDB for role-specific retrieval if available
+        if self._mongodb_service and self._mongodb_service.is_available() and role:
+            retriever = self._mongodb_service.get_retriever(role, k, search_type)
+            if retriever:
+                return retriever
+
+        # Fallback retriever
+        if self._fallback_store:
+            search_kwargs: dict[str, Any] = {"k": k}
+            if filter:
+                search_kwargs["filter"] = filter
+
+            return self._fallback_store.as_retriever(
+                search_type=search_type,
+                search_kwargs=search_kwargs,
+            )
+
+        return None
 
     def format_docs(self, docs: list[Document]) -> str:
         """
         Format retrieved documents into a string for context injection.
+
+        Uses MongoDB service formatter if available (includes role metadata),
+        otherwise uses simple formatting.
         """
+        if self._mongodb_service and self._mongodb_service.is_available():
+            return self._mongodb_service.format_docs(docs)
+
         if not docs:
             return "No relevant context found."
 
@@ -205,36 +223,117 @@ class RAGService:
     async def add_documents(
         self,
         documents: list[Document],
+        role: TeamRole | None = None,
         ids: list[str] | None = None,
     ) -> list[str]:
         """
         Add documents to the vectorstore.
+
+        Args:
+            documents: Documents to add
+            role: Agent role (required for MongoDB, determines collection)
+            ids: Optional document IDs
+
+        Returns:
+            List of document IDs
         """
-        if not self.vector_store:
-            raise RuntimeError(ERR_VECTOR_STORE_NOT_INIT)
+        # Add to MongoDB if role specified and available
+        if self._mongodb_service and self._mongodb_service.is_available() and role:
+            return await self._mongodb_service.add_documents(documents, role)
+
+        # Add to fallback store
+        if self._fallback_store:
+            if hasattr(self._fallback_store, "aadd_documents"):
+                return await self._fallback_store.aadd_documents(documents, ids=ids)
+            else:
+                return self._fallback_store.add_documents(documents, ids=ids)
 
-        # Use add_documents if available (async support varies by store)
-        if hasattr(self.vector_store, "aadd_documents"):
-            return await self.vector_store.aadd_documents(documents, ids=ids)
-        else:
-            return self.vector_store.add_documents(documents, ids=ids)
+        raise RuntimeError(ERR_VECTOR_STORE_NOT_INIT)
 
-    async def delete_documents(self, ids: list[str]) -> bool:
+    async def delete_documents(
+        self,
+        ids: list[str],
+        role: TeamRole | None = None,
+    ) -> bool:
         """
         Delete documents from the vectorstore by ID.
+
+        Args:
+            ids: Document IDs to delete
+            role: Agent role (required for MongoDB deletion)
+
+        Returns:
+            True if successful
         """
-        if not self.vector_store:
-            raise RuntimeError(ERR_VECTOR_STORE_NOT_INIT)
-
-        try:
-            if hasattr(self.vector_store, "adelete"):
-                await self.vector_store.adelete(ids=ids)
-            elif hasattr(self.vector_store, "delete"):
-                self.vector_store.delete(ids=ids)
-            else:
-                logger.warning("Vectorstore does not support deletion")
+        # Delete from MongoDB if role specified and available
+        if self._mongodb_service and self._mongodb_service.is_available() and role:
+            return await self._mongodb_service.delete_documents(ids, role)
+
+        # Delete from fallback store
+        if self._fallback_store:
+            try:
+                if hasattr(self._fallback_store, "adelete"):
+                    await self._fallback_store.adelete(ids=ids)
+                elif hasattr(self._fallback_store, "delete"):
+                    self._fallback_store.delete(ids=ids)
+                else:
+                    logger.warning("Fallback store does not support deletion")
+                    return False
+                return True
+            except Exception as e:
+                logger.error(f"Error deleting documents: {e}")
                 return False
-            return True
-        except Exception as e:
-            logger.error(f"Error deleting documents: {e}")
-            return False
+
+        return False
+
+    def health_check(self) -> dict[str, Any]:
+        """
+        Return health status of RAG service.
+
+        Returns:
+            Dict with status and backend information
+        """
+        result: dict[str, Any] = {
+            "fallback_store_initialized": self._fallback_store is not None,
+        }
+
+        if self._mongodb_service:
+            result["mongodb"] = self._mongodb_service.health_check()
+            result["primary_backend"] = (
+                "mongodb" if self._mongodb_service.is_available() else "fallback"
+            )
+        else:
+            result["mongodb"] = {"status": "not_configured"}
+            result["primary_backend"] = "fallback"
+
+        return result
+
+    def is_mongodb_available(self) -> bool:
+        """Check if MongoDB RAG backend is available."""
+        return (
+            self._mongodb_service is not None and self._mongodb_service.is_available()
+        )
+
+    def get_roles_with_rag(self) -> list[TeamRole]:
+        """Get list of agent roles that have RAG collections configured."""
+        if self._mongodb_service:
+            return self._mongodb_service.get_roles_with_rag()
+        return []
+
+
+# Module-level singleton
+_rag_service: RAGService | None = None
+
+
+def get_rag_service() -> RAGService:
+    """Get singleton RAG service instance."""
+    global _rag_service
+    if _rag_service is None:
+        _rag_service = RAGService()
+    return _rag_service
+
+
+def reset_rag_service() -> None:
+    """Reset the RAG service singleton (for testing)."""
+    global _rag_service
+    _rag_service = None

app/core/schemas.py

@@ -44,10 +44,6 @@ class TeamRole(str, Enum):
     JUDGE = "judge"
 
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Enhanced Judge Output Schema
-# ─────────────────────────────────────────────────────────────────────────────
-
 
 class JudgeIssue(BaseModel):
     id: str = Field(..., description="Issue ID or related FR/NFR ID")
@@ -69,11 +65,6 @@ class JudgeOutput(BaseModel):
     reasoning: str
 
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Existing Schemas (unchanged structure, enhanced docs)
-# ─────────────────────────────────────────────────────────────────────────────
-
-
 class AgentMessage(BaseModel):
     role: TeamRole
     content: str
@@ -130,7 +121,7 @@ class TokenData(BaseModel):
 class ProjectBase(BaseModel):
     title: str
     description: str | None = None
-    artifacts: dict[str, Any]  # JSON content
+    artifacts: dict[str, Any]
 
 
 class ProjectCreate(ProjectBase):

app/prompts/product_owner.md

@@ -13,10 +13,12 @@ Great product ownership means translating user needs and business goals into a c
 1.  Analyze input from the Project Refiner.
 2.  Define a concise product vision aligned with strategic objectives.
 3.  Identify and prioritize key features using MoSCoW (Must, Should, Could, Won't).
-4.  Write user stories that capture real user goals and benefits (INVEST criteria).
+4.  Write **AT LEAST 4-6 user stories** that capture real user goals and benefits (INVEST criteria).
 5.  Establish clear, testable acceptance criteria for each feature.
 6.  Document assumptions and open questions.
 
+**IMPORTANT:** Generate AT LEAST 4 user stories (US1, US2, US3, US4 minimum). For MVP scope, aim for 4-6 user stories to provide adequate coverage.
+
 **Output Structure:**
 ## MARKDOWN
 
@@ -27,20 +29,39 @@ Great product ownership means translating user needs and business goals into a c
 ### Must Have (MVP)
 - **F1:** [Title] - [Brief description]
 - **F2:** [Title] - [Brief description]
+- **F3:** [Title] - [Brief description]
+- **F4:** [Title] - [Brief description]
 
 ### Should Have (Post-MVP)
-- **F3:** [Title] - [Brief description]
+- **F5:** [Title] - [Brief description]
+- **F6:** [Title] - [Brief description]
 
 ## User Stories
 1. **US1:** As a [user type], I want [goal] so that [benefit]
    - **Acceptance Criteria:**
      - [Criterion 1]
      - [Criterion 2]
+     - [Criterion 3]
+
 2. **US2:** As a [user type], I want [goal] so that [benefit]
    - **Acceptance Criteria:**
      - [Criterion 1]
      - [Criterion 2]
 
+3. **US3:** As a [user type], I want [goal] so that [benefit]
+   - **Acceptance Criteria:**
+     - [Criterion 1]
+     - [Criterion 2]
+
+4. **US4:** As a [user type], I want [goal] so that [benefit]
+   - **Acceptance Criteria:**
+     - [Criterion 1]
+     - [Criterion 2]
+
+5. **US5:** As a [user type], I want [goal] so that [benefit]
+   - **Acceptance Criteria:**
+     - [Criterion 1]
+
 ## Assumptions & Constraints
 [List any assumptions made about the project scope or constraints]
 

app/routers/health.py

@@ -26,6 +26,14 @@ from app.core.resilience import get_all_circuit_breakers, get_all_request_queues
 
 load_dotenv()
 
+
+# Lazy import for RAG to avoid circular imports
+def _get_rag_service():
+    from app.core.rag import get_rag_service
+
+    return get_rag_service()
+
+
 router = APIRouter(prefix="/health", tags=["Health"])
 
 
@@ -60,15 +68,17 @@ async def readiness_probe():
     if not any(check in checks for check in critical_checks):
         is_ready = True
 
-    status_code = status.HTTP_200_OK if is_ready else status.HTTP_503_SERVICE_UNAVAILABLE
+    status_code = (
+        status.HTTP_200_OK if is_ready else status.HTTP_503_SERVICE_UNAVAILABLE
+    )
 
     return JSONResponse(
         status_code=status_code,
         content={
             "status": "ready" if is_ready else "not_ready",
             "checks": checks,
-            "timestamp": datetime.now(UTC).isoformat()
-        }
+            "timestamp": datetime.now(UTC).isoformat(),
+        },
     )
 
 
@@ -87,24 +97,19 @@ async def detailed_health_check():
 
     # Get circuit breaker status
     circuit_breakers = {
-        name: cb.get_status()
-        for name, cb in get_all_circuit_breakers().items()
+        name: cb.get_status() for name, cb in get_all_circuit_breakers().items()
     }
 
     # Get request queue status
     request_queues = {
-        name: queue.get_status()
-        for name, queue in get_all_request_queues().items()
+        name: queue.get_status() for name, queue in get_all_request_queues().items()
     }
 
     # Get provider status
     provider_status = get_provider_manager().get_provider_status()
 
     # Overall status
-    all_healthy = all(
-        check.get("status") == "healthy"
-        for check in checks.values()
-    )
+    all_healthy = all(check.get("status") == "healthy" for check in checks.values())
 
     return {
         "status": "healthy" if all_healthy else "degraded",
@@ -116,15 +121,9 @@ async def detailed_health_check():
         "circuit_breakers": circuit_breakers,
         "request_queues": request_queues,
         "llm_providers": provider_status,
-        "performance": {
-            "window_seconds": 300,
-            "operations": performance_stats
-        },
-        "errors": {
-            "window_seconds": 3600,
-            "summary": error_summary
-        },
-        "cost": cost_stats
+        "performance": {"window_seconds": 300, "operations": performance_stats},
+        "errors": {"window_seconds": 3600, "summary": error_summary},
+        "cost": cost_stats,
     }
 
 
@@ -140,8 +139,7 @@ async def get_metrics():
     # Format as Prometheus-style metrics (simplified)
     metrics = {
         "specsbeforecode_requests_total": sum(
-            stats.get("count", 0)
-            for stats in performance_stats.values()
+            stats.get("count", 0) for stats in performance_stats.values()
         ),
         "specsbeforecode_tokens_used_monthly": cost_stats.get("monthly_tokens_used", 0),
         "specsbeforecode_budget_remaining": cost_stats.get("budget_remaining", 0),
@@ -152,12 +150,54 @@ async def get_metrics():
     for op, stats in performance_stats.items():
         safe_op = op.replace(".", "_").replace("-", "_")
         metrics[f"specsbeforecode_op_{safe_op}_count"] = stats.get("count", 0)
-        metrics[f"specsbeforecode_op_{safe_op}_avg_duration_ms"] = stats.get("avg_duration_ms", 0)
-        metrics[f"specsbeforecode_op_{safe_op}_success_rate"] = stats.get("success_rate", 0)
+        metrics[f"specsbeforecode_op_{safe_op}_avg_duration_ms"] = stats.get(
+            "avg_duration_ms", 0
+        )
+        metrics[f"specsbeforecode_op_{safe_op}_success_rate"] = stats.get(
+            "success_rate", 0
+        )
 
     return metrics
 
 
+@router.get("/rag")
+async def rag_health_check():
+    """
+    Check RAG (Retrieval-Augmented Generation) service health.
+
+    Returns:
+    - MongoDB connection status
+    - Configured collections
+    - Missing collections that need setup
+    - Fallback store status
+    """
+    try:
+        rag_service = _get_rag_service()
+        health = rag_service.health_check()
+
+        # Add role information
+        roles_with_rag = rag_service.get_roles_with_rag()
+        health["roles_with_rag"] = [role.value for role in roles_with_rag]
+        health["mongodb_available"] = rag_service.is_mongodb_available()
+
+        # Determine overall status
+        if health.get("mongodb", {}).get("status") == "connected":
+            health["status"] = "healthy"
+        elif health.get("fallback_store_initialized"):
+            health["status"] = "degraded"
+            health["message"] = "Using in-memory fallback - MongoDB not available"
+        else:
+            health["status"] = "unhealthy"
+            health["message"] = "No RAG backend available"
+
+        return health
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e),
+        }
+
+
 async def _run_health_checks() -> dict[str, dict[str, Any]]:
     """Run all health checks and return results.
 
@@ -191,14 +231,11 @@ def _check_database() -> dict[str, Any]:
         with engine.connect() as conn:
             conn.execute(text("SELECT 1"))
 
-        return {
-            "status": "healthy",
-            "message": "Database connection successful"
-        }
+        return {"status": "healthy", "message": "Database connection successful"}
     except Exception as e:
         return {
             "status": "unhealthy",
-            "message": f"Database connection failed: {str(e)}"
+            "message": f"Database connection failed: {str(e)}",
         }
 
 
@@ -208,10 +245,7 @@ def _check_nvidia_api() -> dict[str, Any]:
     base_url = os.getenv("NVIDIA_BASE_URL")
 
     if not api_key:
-        return {
-            "status": "unhealthy",
-            "message": "NVIDIA_API_KEY not configured"
-        }
+        return {"status": "unhealthy", "message": "NVIDIA_API_KEY not configured"}
 
     # Check circuit breaker status instead of making actual API call
     circuit_breakers = get_all_circuit_breakers()
@@ -220,13 +254,13 @@ def _check_nvidia_api() -> dict[str, Any]:
     if nvidia_cb and nvidia_cb.state.value == "open":
         return {
             "status": "degraded",
-            "message": "Circuit breaker is open - service may be experiencing issues"
+            "message": "Circuit breaker is open - service may be experiencing issues",
         }
 
     return {
         "status": "healthy",
         "message": "NVIDIA API configured",
-        "base_url": base_url
+        "base_url": base_url,
     }
 
 
@@ -238,12 +272,12 @@ def _check_langsmith() -> dict[str, Any]:
     if not api_key:
         return {
             "status": "degraded",
-            "message": "LangSmith API key not configured - observability limited"
+            "message": "LangSmith API key not configured - observability limited",
         }
 
     return {
         "status": "healthy",
         "message": "LangSmith configured",
         "tracing_enabled": tracing,
-        "project": os.getenv("LANGSMITH_PROJECT", "default")
+        "project": os.getenv("LANGSMITH_PROJECT", "default"),
     }

corpus_rag/RAG_INDEX_DECISION.md

@@ -0,0 +1,64 @@
+# RAG Index Decision Log
+
+**Date:** February 6, 2026
+**Context:** Testing on MongoDB Atlas Free Tier (M0)
+
+## Decision
+
+Due to the free tier's limitation of **3 Atlas Search (FTS) indexes maximum**, only 3 agent collections have active vector search indexes.
+
+### Selected Agents for Indexing
+
+| Rank | Agent Role | Rationale |
+|------|------------|-----------|
+| 1 | **Product Owner** | Foundation of all downstream artifacts. PRD quality affects every subsequent phase. |
+| 2 | **Solution Architect** | Critical technical decisions impact feasibility, scalability, and integration across all phases. |
+| 3 | **Technical Writer** | Documentation quality directly affects user-facing output and project success metrics. |
+
+### Excluded Agents
+
+| Agent Role | Reason |
+|------------|--------|
+| Business Analyst | Lower priority for MVP testing; business rules can be derived from PO output |
+| Security Analyst | Security patterns can use generic guidance; threat modeling less critical for prototypes |
+| UX Designer | UI patterns are more intuitive; prototyping benefits less from RAG |
+| API Designer | API contracts can be derived from architecture |
+| QA Strategist | Testing approaches are relatively standardized |
+| DevOps Architect | Deployment patterns less critical for initial spec generation |
+| Environment Engineer | Setup guides are procedural and template-based |
+| Data Architect | Data models can be derived from architecture and requirements |
+| API Designer | (already covered) |
+
+## Future Upgrade Path
+
+When upgrading to M10+ cluster:
+1. Enable indexes on all 11 collections
+2. Update `scripts/setup_mongodb_indexes.py` to remove the index limit logic
+3. Run seed script again if needed
+
+## Current Index Status
+
+```
+Active Indexes (3):
+  - rag_product_owner
+  - rag_solution_architect
+  - rag_technical_writer
+
+Collections without Indexes (8):
+  - rag_business_analyst
+  - rag_data_architect
+  - rag_security_analyst
+  - rag_ux_designer
+  - rag_api_designer
+  - rag_qa_strategist
+  - rag_devops_architect
+  - rag_environment_engineer
+```
+
+## Impact on Agents
+
+Agents without RAG indexes will fall back to:
+1. In-memory vector store (if documents exist)
+2. No retrieval (empty context)
+
+For production, all agents should have their own RAG collections indexed.

corpus_rag/api_designer/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: API Designer
+Purpose: Define API contracts, endpoints, and data shapes for services.
+
+Core responsibilities
+- Design REST/GraphQL endpoints and schemas.
+- Specify request/response formats and error handling.
+- Align with data models and business requirements.
+
+Required sections in output
+- API overview and base URL
+- Endpoints with methods and payloads
+- Error model and status codes
+- Authentication and rate limiting notes
+
+Quality gates
+- Consistency: aligns with data models and UX needs
+- Completeness: covers all workflows
+- Clarity: unambiguous request/response schemas

corpus_rag/api_designer/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+OpenAPI Specification (OAS)
+Standard for describing REST APIs. Use to produce a machine-readable contract and validation.
+
+Microsoft REST API Guidelines
+Conventions for resource naming, filtering, pagination, and errors. Use to standardize endpoints.
+
+Google API Design Guide
+Best practices for consistency and long-term evolution. Use for naming and error handling guidance.

corpus_rag/business_analyst/role_playbook.txt

@@ -0,0 +1,19 @@
+Role: Business Analyst
+Purpose: Translate product goals into detailed business requirements, workflows, and business rules.
+
+Core responsibilities
+- Document workflows and process flows.
+- Capture business rules, exceptions, and edge cases.
+- Clarify functional requirements and constraints.
+
+Required sections in output
+- Business objectives and stakeholders
+- Process flows (happy path and exceptions)
+- Business rules and validations
+- Functional requirements list
+- Assumptions, risks, and dependencies
+
+Quality gates
+- Completeness: all major workflows covered
+- Consistency: aligns with PRD and data models
+- Traceability: each requirement ties to a goal or story

corpus_rag/business_analyst/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+BABOK (Business Analysis Body of Knowledge)
+Industry standard for eliciting, analyzing, and managing requirements. Use it to structure stakeholder analysis and requirement validation.
+
+BPMN 2.0 (Business Process Model and Notation)
+Standard visual language for process flows. Use to represent end-to-end workflows, decision points, and exceptions.
+
+ISO/IEC/IEEE 29148
+Defines good requirements characteristics. Use to validate clarity, consistency, and testability.

corpus_rag/data_architect/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: Data Architect
+Purpose: Define data models, entities, relationships, and data governance concerns.
+
+Core responsibilities
+- Produce entity-relationship model and data dictionary.
+- Define data validation rules and lifecycle.
+- Ensure alignment with API contracts and business rules.
+
+Required sections in output
+- Entities and relationships
+- Key fields and constraints
+- Data dictionary (field definitions)
+- Data lifecycle and retention notes
+
+Quality gates
+- Consistency: matches API and business requirements
+- Completeness: covers all core domain entities
+- Integrity: constraints and validation rules defined

corpus_rag/data_architect/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+DAMA-DMBOK
+Comprehensive data management guide. Use for governance, data quality, and stewardship considerations.
+
+UML for data models
+Standard notation for entities and relationships. Use to document ERDs with clear cardinalities.
+
+Database Answers patterns
+Collection of common data model patterns. Use for inspiration and validation of schema design.

corpus_rag/devops_architect/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: DevOps Architect
+Purpose: Define CI/CD, deployment, and operational reliability plan.
+
+Core responsibilities
+- Design pipelines, environments, and monitoring.
+- Define infrastructure requirements and scaling strategy.
+- Align with security and architecture constraints.
+
+Required sections in output
+- CI/CD pipeline overview
+- Environments and deployment strategy
+- Monitoring, logging, and alerting
+- Backup and rollback strategy
+
+Quality gates
+- Reliability: clear rollback and monitoring
+- Security: secrets management and least privilege
+- Consistency: aligns with architecture choices

corpus_rag/devops_architect/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+Google SRE Book
+Reliability principles: SLIs/SLOs, error budgets, incident response. Use to set operational targets.
+
+12-Factor App
+Guides cloud-native deployment (stateless, config via env). Use to shape deployment and scaling approach.
+
+Docker best practices
+Image hygiene, minimal layers, and security hardening. Use for containerized build guidance.

corpus_rag/environment_engineer/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: Environment Engineer
+Purpose: Define local setup, developer tooling, and environment configuration.
+
+Core responsibilities
+- Provide step-by-step local setup and prerequisites.
+- Document environment variables and tooling versions.
+- Ensure developer onboarding is fast and repeatable.
+
+Required sections in output
+- Prerequisites and tooling versions
+- Setup steps (install, configure, run)
+- Environment variable reference
+- Troubleshooting tips
+
+Quality gates
+- Reproducibility: steps work from clean machine
+- Clarity: copy/paste friendly commands
+- Consistency: matches DevOps and architecture choices

corpus_rag/environment_engineer/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+12-Factor App
+Configuration and portability guidance. Use to structure environment variables and secrets.
+
+Official tool docs (Node, Python, Docker, Git)
+Use vendor-recommended install paths and versions to avoid inconsistencies.
+
+Node/Python best practices
+Use virtual envs, lock files, and deterministic builds. Apply to keep setup stable.

corpus_rag/product_owner/role_playbook.txt

@@ -0,0 +1,22 @@
+Role: Product Owner
+Purpose: Translate refined project brief into a clear product requirements document (PRD) and prioritized user stories.
+
+Core responsibilities
+- Define product goals, scope, success metrics, and non-goals.
+- Produce a PRD with features, user stories, acceptance criteria, and priorities.
+- Resolve ambiguities from the project refiner output.
+
+Required sections in output
+- Product vision and target users
+- Problem statement and goals
+- Scope and non-goals
+- Feature list with priority (MVP vs later)
+- User stories with acceptance criteria
+- Constraints, assumptions, and dependencies
+- Success metrics and KPIs
+
+Quality gates
+- Completeness: all required sections present
+- Clarity: unambiguous, testable acceptance criteria
+- Feasibility: within constraints and timeline
+- Consistency: aligns with project brief and later phase inputs

corpus_rag/product_owner/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+IEEE 29148 (Requirements Engineering)
+Defines best practices for requirements quality: complete, consistent, unambiguous, verifiable, and feasible. Use it to structure the PRD and validate acceptance criteria.
+
+User Story Mapping (Jeff Patton)
+Organizes stories along user activities to keep scope visible. Apply to ensure MVP coverage and reveal gaps in flows.
+
+Atlassian PRD guidance
+Practical PRD structure: problem, goals, scope, user stories, risks. Use as a template for readable stakeholder documents.

corpus_rag/qa_strategist/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: QA Strategist
+Purpose: Define test strategy, coverage, and quality assurance approach.
+
+Core responsibilities
+- Create test plan across unit, integration, and E2E layers.
+- Define risk-based testing priorities.
+- Provide quality gates and acceptance criteria.
+
+Required sections in output
+- Test strategy and pyramid distribution
+- Key test types and tooling
+- Risk areas and regression scope
+- Release quality gates
+
+Quality gates
+- Coverage: critical flows fully tested
+- Balance: unit/integration/E2E ratios reasonable
+- Traceability: tests map to requirements

corpus_rag/qa_strategist/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+ISO/IEC 25010
+Software quality model (reliability, security, usability, etc.). Use to define quality attributes and test focus.
+
+ISTQB Foundation Syllabus
+Standard testing terminology and practices. Use for test design and reporting consistency.
+
+Test Pyramid
+Guides proportion of tests (more unit, fewer E2E). Use to keep suite fast and reliable.

corpus_rag/security_analyst/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: Security Analyst
+Purpose: Identify threats, define security requirements, and recommend mitigations.
+
+Core responsibilities
+- Produce threat model and security requirements.
+- Specify authN/authZ approach, data protection, and logging.
+- Highlight OWASP risks and mitigations.
+
+Required sections in output
+- Threat model (assets, threats, mitigations)
+- Security requirements and controls
+- Authentication and authorization strategy
+- Data protection and privacy considerations
+
+Quality gates
+- Coverage: top web threats addressed
+- Consistency: aligns with architecture and data model
+- Practicality: mitigations are implementable

corpus_rag/security_analyst/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+OWASP Top 10
+Top web app security risks (e.g., injection, auth failures). Use as a baseline checklist for threats and mitigations.
+
+OWASP ASVS
+Verification standard with security control requirements. Use to derive testable security requirements by level.
+
+NIST Cybersecurity Framework
+High-level framework (Identify, Protect, Detect, Respond, Recover). Use to ensure broad security posture.

corpus_rag/solution_architect/role_playbook.txt

@@ -0,0 +1,19 @@
+Role: Solution Architect
+Purpose: Define system architecture, tech stack decisions, and high-level design patterns.
+
+Core responsibilities
+- Choose frontend/backend architecture (SPA/SSR), hosting approach, and integrations.
+- Produce system design (components, data flow, deployment).
+- Capture trade-offs and rationale (ADRs).
+
+Required sections in output
+- Architecture overview and constraints
+- Key components and interfaces
+- Tech stack choices with rationale
+- Deployment topology and integration points
+- Non-functional requirements (scalability, reliability)
+
+Quality gates
+- Feasibility: implementable with chosen stack
+- Consistency: aligns with security, data, and API design
+- Clarity: diagrams or structured description of components

corpus_rag/solution_architect/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+C4 Model
+Simple, layered diagrams (Context, Container, Component, Code). Use to communicate architecture to different audiences.
+
+12-Factor App
+Best practices for cloud-native apps: config in env, stateless processes, logs as streams. Use to guide backend design and deployment.
+
+AWS Well-Architected Framework
+Five pillars (operational excellence, security, reliability, performance, cost). Use as a checklist for architecture decisions.

corpus_rag/technical_writer/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: Technical Writer
+Purpose: Create clear, structured documentation using consistent style and information architecture.
+
+Core responsibilities
+- Define doc set structure and templates.
+- Standardize tone, terminology, and formatting.
+- Ensure documentation is complete and user-focused.
+
+Required sections in output
+- Documentation structure (overview, how-to, reference)
+- Writing style guidelines
+- Template examples
+- Update and maintenance guidance
+
+Quality gates
+- Clarity: readable and actionable content
+- Consistency: uniform structure across docs
+- Completeness: covers user journeys and references

corpus_rag/technical_writer/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+Google Developer Documentation Style Guide
+Best practices for clear, consistent technical writing. Use to standardize tone and terminology.
+
+Microsoft Writing Style Guide
+Guidelines for UI labels, procedures, and accessibility. Use for consistent phrasing.
+
+Diátaxis Framework
+Documentation types: tutorials, how-to guides, reference, explanation. Use to structure the doc set.

corpus_rag/ux_designer/role_playbook.txt

@@ -0,0 +1,18 @@
+Role: UX Designer
+Purpose: Define user flows, interaction patterns, and usability guidelines.
+
+Core responsibilities
+- Create user journeys and key screens/components.
+- Ensure accessibility and usability best practices.
+- Align UX with business workflows and data requirements.
+
+Required sections in output
+- User personas and primary tasks
+- User flows (happy path and exceptions)
+- Key UI components and layout guidelines
+- Accessibility and usability notes
+
+Quality gates
+- Usability: clear flows and minimal friction
+- Accessibility: meets WCAG 2.1 AA basics
+- Consistency: aligns with business processes

corpus_rag/ux_designer/standards_quickref.txt

@@ -0,0 +1,10 @@
+Standards and frameworks (brief summaries)
+
+Nielsen Norman Heuristics
+10 usability principles (visibility, consistency, error prevention). Use to evaluate interaction design.
+
+WCAG 2.1
+Accessibility guidelines (perceivable, operable, understandable, robust). Use to ensure keyboard access and contrast.
+
+Material Design (web UI patterns)
+UI guidelines for consistency and components. Use as reference for layout and interaction patterns.

pyproject.toml

@@ -1,5 +1,3 @@
-
-
 [tool.ruff.lint]
 exclude = ["tests", "tests/*", "*/tests/*", "*/tests.py"]
 
@@ -39,7 +37,9 @@ dependencies = [
   # Database
   "sqlalchemy>=2.0.0",
   "psycopg2-binary>=2.9.9",
-  "pinecone",
+  # MongoDB Vector Store
+  "pymongo>=4.6.0",
+  "langchain-mongodb>=0.1.0",
   "hydra-core>=1.3.2",
   "lightning>=2.6.0",
   "fiddle>=0.3.0",

requirements.txt

@@ -1,5 +1,5 @@
 # This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml -o requirements.txt --python-version 3.12
+#    uv pip compile pyproject.toml --output-file requirements.txt
 absl-py==2.3.1
     # via fiddle
 aiohappyeyeballs==2.6.1
@@ -32,7 +32,6 @@ certifi==2025.11.12
     # via
     #   httpcore
     #   httpx
-    #   pinecone
     #   requests
 cffi==2.0.0
     # via cryptography
@@ -50,12 +49,14 @@ cryptography==46.0.3
     # via python-jose
 defusedxml==0.7.1
     # via fpdf2
+dnspython==2.8.0
+    # via pymongo
 ecdsa==0.19.1
     # via python-jose
 fastapi==0.123.5
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 fiddle==0.3.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 filelock==3.20.2
     # via torch
 filetype==1.2.0
@@ -63,7 +64,7 @@ filetype==1.2.0
 fonttools==4.61.0
     # via fpdf2
 fpdf2==2.8.5
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 frozenlist==1.8.0
     # via
     #   aiohttp
@@ -76,7 +77,7 @@ fsspec==2025.12.0
 google-api-core==2.28.1
     # via google-api-python-client
 google-api-python-client==2.187.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 google-auth==2.41.1
     # via
     #   google-api-core
@@ -86,7 +87,7 @@ google-auth==2.41.1
 google-auth-httplib2==0.2.1
     # via google-api-python-client
 google-auth-oauthlib==1.2.3
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 googleapis-common-protos==1.72.0
     # via google-api-core
 graphviz==0.21
@@ -109,7 +110,7 @@ httpx==0.28.1
     #   langsmith
     #   upstash-redis
 hydra-core==1.3.2
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 idna==3.11
     # via
     #   anyio
@@ -124,20 +125,34 @@ jsonpatch==1.33
     # via langchain-core
 jsonpointer==3.0.0
     # via jsonpatch
+langchain==1.1.2
+    # via langchain-mongodb
+langchain-classic==1.0.0
+    # via langchain-mongodb
 langchain-core==1.1.0
     # via
-    #   ideasprinter-api (pyproject.toml)
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain
+    #   langchain-classic
+    #   langchain-mongodb
     #   langchain-nvidia-ai-endpoints
     #   langchain-text-splitters
     #   langgraph
     #   langgraph-checkpoint
     #   langgraph-prebuilt
+langchain-mongodb==0.9.0
+    # via specs-before-code-api (pyproject.toml)
 langchain-nvidia-ai-endpoints==1.0.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 langchain-text-splitters==1.0.0
-    # via ideasprinter-api (pyproject.toml)
+    # via
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain-classic
+    #   langchain-mongodb
 langgraph==1.0.4
-    # via ideasprinter-api (pyproject.toml)
+    # via
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain
 langgraph-checkpoint==3.0.1
     # via
     #   langgraph
@@ -148,12 +163,15 @@ langgraph-sdk==0.2.12
     # via langgraph
 langsmith==0.4.53
     # via
-    #   ideasprinter-api (pyproject.toml)
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain-classic
     #   langchain-core
+lark==1.3.1
+    # via langchain-mongodb
 libcst==1.8.6
     # via fiddle
 lightning==2.6.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 lightning-utilities==0.15.2
     # via
     #   lightning
@@ -171,7 +189,8 @@ networkx==3.6.1
     # via torch
 numpy==2.3.5
     # via
-    #   ideasprinter-api (pyproject.toml)
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain-mongodb
     #   torchmetrics
 oauthlib==3.3.1
     # via requests-oauthlib
@@ -181,7 +200,6 @@ orjson==3.11.4
     # via
     #   langgraph-sdk
     #   langsmith
-    #   pinecone
 ormsgpack==1.12.0
     # via langgraph-checkpoint
 packaging==24.2
@@ -191,19 +209,12 @@ packaging==24.2
     #   langsmith
     #   lightning
     #   lightning-utilities
-    #   pinecone-plugin-assistant
     #   pytorch-lightning
     #   torchmetrics
 passlib==1.7.4
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 pillow==12.0.0
     # via fpdf2
-pinecone==8.0.0
-    # via ideasprinter-api (pyproject.toml)
-pinecone-plugin-assistant==3.0.1
-    # via pinecone
-pinecone-plugin-interface==0.0.7
-    # via pinecone
 propcache==0.4.1
     # via
     #   aiohttp
@@ -216,7 +227,7 @@ protobuf==6.33.2
     #   googleapis-common-protos
     #   proto-plus
 psycopg2-binary==2.9.11
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 pyasn1==0.6.1
     # via
     #   pyasn1-modules
@@ -228,37 +239,46 @@ pycparser==2.23
     # via cffi
 pydantic==2.12.4
     # via
-    #   ideasprinter-api (pyproject.toml)
+    #   specs-before-code-api (pyproject.toml)
     #   fastapi
+    #   langchain
+    #   langchain-classic
     #   langchain-core
     #   langgraph
     #   langsmith
 pydantic-core==2.41.5
     # via pydantic
+pymongo==4.16.0
+    # via
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain-mongodb
+    #   pymongo-search-utils
+pymongo-search-utils==0.3.0
+    # via langchain-mongodb
 pyparsing==3.2.5
     # via httplib2
-python-dateutil==2.9.0.post0
-    # via pinecone
 python-dotenv==1.2.1
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 python-jose==3.5.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 python-multipart==0.0.20
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 pytorch-lightning==2.6.0
     # via lightning
 pyyaml==6.0.3
     # via
+    #   langchain-classic
     #   langchain-core
-    #   libcst
     #   lightning
     #   omegaconf
     #   pytorch-lightning
+pyyaml-ft==8.0.0
+    # via libcst
 requests==2.32.5
     # via
     #   google-api-core
+    #   langchain-classic
     #   langsmith
-    #   pinecone-plugin-assistant
     #   requests-oauthlib
     #   requests-toolbelt
 requests-oauthlib==2.0.0
@@ -274,11 +294,11 @@ setuptools==80.9.0
     #   lightning-utilities
     #   torch
 six==1.17.0
-    # via
-    #   ecdsa
-    #   python-dateutil
+    # via ecdsa
 sqlalchemy==2.0.45
-    # via ideasprinter-api (pyproject.toml)
+    # via
+    #   specs-before-code-api (pyproject.toml)
+    #   langchain-classic
 starlette==0.50.0
     # via fastapi
 sympy==1.14.0
@@ -300,35 +320,29 @@ tqdm==4.67.1
     #   pytorch-lightning
 typing-extensions==4.15.0
     # via
-    #   aiosignal
-    #   anyio
     #   fastapi
     #   fiddle
     #   langchain-core
     #   lightning
     #   lightning-utilities
-    #   pinecone
     #   pydantic
     #   pydantic-core
     #   pytorch-lightning
     #   sqlalchemy
-    #   starlette
     #   torch
     #   typing-inspection
 typing-inspection==0.4.2
     # via pydantic
 upstash-redis==1.5.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 uritemplate==4.2.0
     # via google-api-python-client
 urllib3==2.5.0
-    # via
-    #   pinecone
-    #   requests
+    # via requests
 uuid-utils==0.12.0
     # via langsmith
 uvicorn==0.38.0
-    # via ideasprinter-api (pyproject.toml)
+    # via specs-before-code-api (pyproject.toml)
 xxhash==3.6.0
     # via langgraph
 yarl==1.22.0

scripts/seed_rag_data.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""
+Seed MongoDB collections with example documents for each agent role.
+
+This script:
+1. Reads documents from corpus_rag/<agent_role>/ directories
+2. Splits them into chunks
+3. Embeds and stores them in the appropriate MongoDB collection
+
+
+Usage:
+    uv run python scripts/seed_rag_data.py              # Seed all collections
+    uv run python scripts/seed_rag_data.py --role product_owner  # Seed specific role
+    uv run python scripts/seed_rag_data.py --dry-run   # Preview without inserting
+
+Environment Variables:
+    MONGODB_URI         - MongoDB connection string
+    MONGODB_DATABASE    - Database name (default: specs_before_code)
+    NVIDIA_API_KEY      - Required for generating embeddings
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Mapping from TeamRole enum values to directory names
+ROLE_DIRECTORIES = {
+    "product_owner": "product_owner",
+    "business_analyst": "business_analyst",
+    "solution_architect": "solution_architect",
+    "data_architect": "data_architect",
+    "security_analyst": "security_analyst",
+    "ux_designer": "ux_designer",
+    "api_designer": "api_designer",
+    "qa_strategist": "qa_strategist",
+    "devops_architect": "devops_architect",
+    "environment_engineer": "environment_engineer",
+    "technical_writer": "technical_writer",
+}
+
+# Base directory for corpus files
+CORPUS_DIR = Path(__file__).parent.parent / "corpus_rag"
+
+
+async def seed_collection(
+    role_name: str,
+    directory_name: str,
+    dry_run: bool = False,
+) -> dict:
+    """
+    Seed a single agent's collection with documents from directory.
+
+    Args:
+        role_name: The TeamRole enum value (e.g., "product_owner")
+        directory_name: The subdirectory under corpus_rag/
+        dry_run: If True, only count documents without inserting
+
+    Returns:
+        Dict with stats: chunks_found, chunks_inserted, errors
+    """
+    from langchain_core.documents import Document
+    from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+    from app.core.mongodb_rag import get_mongodb_rag_service
+    from app.core.schemas import TeamRole
+
+    result = {
+        "role": role_name,
+        "files_found": 0,
+        "chunks_found": 0,
+        "chunks_inserted": 0,
+        "errors": [],
+    }
+
+    # Get the TeamRole enum value
+    try:
+        role = TeamRole(role_name)
+    except ValueError:
+        result["errors"].append(f"Invalid role: {role_name}")
+        return result
+
+    # Check directory
+    dir_path = CORPUS_DIR / directory_name
+    if not dir_path.exists():
+        result["errors"].append(f"Directory not found: {dir_path}")
+        return result
+
+    # Configure text splitter
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        add_start_index=True,
+        separators=["\n\n", "\n", ". ", " ", ""],
+    )
+
+    # Find and process documents
+    documents = []
+    supported_extensions = [".md", ".txt", ".yaml", ".yml"]
+
+    for file_path in dir_path.glob("**/*"):
+        if file_path.suffix.lower() not in supported_extensions:
+            continue
+        if file_path.is_dir():
+            continue
+
+        result["files_found"] += 1
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            if not content.strip():
+                continue
+
+            # Split into chunks
+            chunks = splitter.split_text(content)
+
+            for i, chunk in enumerate(chunks):
+                documents.append(
+                    Document(
+                        page_content=chunk,
+                        metadata={
+                            "source": file_path.name,
+                            "chunk_index": i,
+                            "total_chunks": len(chunks),
+                            "role": role_name,
+                            "file_path": str(file_path.relative_to(CORPUS_DIR)),
+                        },
+                    )
+                )
+        except Exception as e:
+            result["errors"].append(f"Error reading {file_path.name}: {e}")
+
+    result["chunks_found"] = len(documents)
+
+    if not documents:
+        result["errors"].append("No documents found to seed")
+        return result
+
+    # Dry run - just report what would be done
+    if dry_run:
+        print(f"  [DRY RUN] Would insert {len(documents)} chunks")
+        return result
+
+    # Insert documents
+    try:
+        rag_service = get_mongodb_rag_service()
+        if not rag_service.is_available():
+            result["errors"].append("MongoDB not available")
+            return result
+
+        ids = await rag_service.add_documents(documents, role)
+        result["chunks_inserted"] = len(ids)
+    except Exception as e:
+        result["errors"].append(f"Error inserting documents: {e}")
+
+    return result
+
+
+async def seed_all(
+    roles: list[str] | None = None,
+    dry_run: bool = False,
+) -> None:
+    """
+    Seed all (or specified) agent collections.
+
+    Args:
+        roles: List of role names to seed, or None for all
+        dry_run: If True, only count documents without inserting
+    """
+    if roles:
+        # Filter to only requested roles
+        to_seed = {k: v for k, v in ROLE_DIRECTORIES.items() if k in roles}
+        if not to_seed:
+            print(f"Error: No valid roles in {roles}")
+            print(f"Valid roles: {list(ROLE_DIRECTORIES.keys())}")
+            return
+    else:
+        to_seed = ROLE_DIRECTORIES
+
+    print(f"Seeding RAG collections{'  [DRY RUN]' if dry_run else ''}...")
+    print(f"Corpus directory: {CORPUS_DIR}")
+    print()
+
+    total_chunks = 0
+    total_inserted = 0
+    total_errors = 0
+
+    for role_name, directory in to_seed.items():
+        print(f"Processing: {role_name}")
+
+        result = await seed_collection(role_name, directory, dry_run)
+
+        total_chunks += result["chunks_found"]
+        total_inserted += result["chunks_inserted"]
+
+        if result["errors"]:
+            total_errors += len(result["errors"])
+            for err in result["errors"]:
+                print(f" {err}")
+        elif result["chunks_inserted"] > 0:
+            print(
+                f" Inserted {result['chunks_inserted']} chunks from {result['files_found']} files"
+            )
+        elif result["chunks_found"] > 0 and dry_run:
+            print(
+                f"  - Found {result['chunks_found']} chunks from {result['files_found']} files"
+            )
+        else:
+            print(f"  - No documents found in corpus_rag/{directory}/")
+
+    # Summary
+    print("\n" + "=" * 50)
+    print("SEEDING COMPLETE")
+    print("=" * 50)
+    print(f"Total chunks found: {total_chunks}")
+    if not dry_run:
+        print(f"Total chunks inserted: {total_inserted}")
+    if total_errors:
+        print(f"Total errors: {total_errors}")
+    print()
+
+
+def create_corpus_directories() -> None:
+    """Create the corpus_rag directory structure."""
+    print(f"Creating corpus directories in: {CORPUS_DIR}")
+    print()
+
+    CORPUS_DIR.mkdir(exist_ok=True)
+
+    for role_name, directory in ROLE_DIRECTORIES.items():
+        dir_path = CORPUS_DIR / directory
+        dir_path.mkdir(exist_ok=True)
+
+        # Create a README placeholder
+        readme_path = dir_path / "README.md"
+        if not readme_path.exists():
+            readme_path.write_text(
+                f"# {role_name.replace('_', ' ').title()} Examples\n\n"
+                f"Place example documents for the {role_name} agent here.\n\n"
+                f"## Supported Formats\n"
+                f"- `.md` (Markdown)\n"
+                f"- `.txt` (Plain text)\n"
+                f"- `.yaml` / `.yml` (YAML)\n\n"
+                f"## Content Guidelines\n"
+                f"Add high-quality examples that the {role_name} agent can learn from.\n",
+                encoding="utf-8",
+            )
+
+        print(f" {directory}/")
+
+    print("\nDone! Add your example documents to the directories above.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Seed MongoDB RAG collections with example documents"
+    )
+    parser.add_argument(
+        "--role",
+        type=str,
+        help="Specific role to seed (e.g., product_owner)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview what would be seeded without inserting",
+    )
+    parser.add_argument(
+        "--create-dirs",
+        action="store_true",
+        help="Create corpus_rag directory structure",
+    )
+    parser.add_argument(
+        "--list-roles",
+        action="store_true",
+        help="List available role names",
+    )
+
+    args = parser.parse_args()
+
+    if args.list_roles:
+        print("Available roles:")
+        for role in ROLE_DIRECTORIES:
+            print(f"  - {role}")
+        return
+
+    if args.create_dirs:
+        create_corpus_directories()
+        return
+
+    # Check MongoDB URI
+    if not os.getenv("MONGODB_URI") and not args.dry_run:
+        print("Error: MONGODB_URI environment variable not set")
+        print("Set it in your .env file or use --dry-run to preview")
+        sys.exit(1)
+
+    # Check NVIDIA API key (needed for embeddings)
+    if not os.getenv("NVIDIA_API_KEY") and not args.dry_run:
+        print("Error: NVIDIA_API_KEY environment variable not set")
+        print("Required for generating embeddings")
+        sys.exit(1)
+
+    roles = [args.role] if args.role else None
+    asyncio.run(seed_all(roles=roles, dry_run=args.dry_run))
+
+
+if __name__ == "__main__":
+    main()

scripts/setup_mongodb_indexes.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+Setup MongoDB Atlas Vector Search indexes for all agent RAG collections.
+
+This script creates:
+1. Collections for each agent role (if they don't exist)
+2. Vector search indexes on each collection
+
+Prerequisites:
+- MongoDB Atlas M10+ cluster (Vector Search requires dedicated cluster)
+- MONGODB_URI environment variable set
+- Database user with dbAdmin permissions
+
+Usage:
+    uv run python scripts/setup_mongodb_indexes.py
+
+Environment Variables:
+    MONGODB_URI         - MongoDB connection string
+    MONGODB_DATABASE    - Database name (default: specs_before_code)
+    MONGODB_INDEX_NAME  - Vector index name (default: vector_index)
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Collection names for all agent roles with RAG
+RAG_COLLECTIONS = [
+    "rag_product_owner",
+    "rag_business_analyst",
+    "rag_solution_architect",
+    "rag_data_architect",
+    "rag_security_analyst",
+    "rag_ux_designer",
+    "rag_api_designer",
+    "rag_qa_strategist",
+    "rag_devops_architect",
+    "rag_environment_engineer",
+    "rag_technical_writer",
+]
+
+# Vector search index definition
+# Configured for nvidia/nv-embed-v1 which outputs 4096-dimensional embeddings
+VECTOR_INDEX_DEFINITION = {
+    "fields": [
+        {
+            "type": "vector",
+            "path": "embedding",
+            "numDimensions": 4096,  # nv-embed-v1 output dimension
+            "similarity": "cosine",
+        },
+        # Filter fields for metadata queries
+        {
+            "type": "filter",
+            "path": "metadata.source",
+        },
+        {
+            "type": "filter",
+            "path": "metadata.role",
+        },
+    ]
+}
+
+
+def setup_indexes() -> None:
+    """Create vector search indexes for all agent collections."""
+    try:
+        from pymongo import MongoClient
+        from pymongo.operations import SearchIndexModel
+    except ImportError:
+        print("Error: pymongo not installed. Run: uv add pymongo")
+        sys.exit(1)
+
+    # Get configuration
+    uri = os.getenv("MONGODB_URI")
+    db_name = os.getenv("MONGODB_DATABASE", "specs_before_code")
+    index_name = os.getenv("MONGODB_INDEX_NAME", "vector_index")
+
+    if not uri:
+        print("Error: MONGODB_URI environment variable not set")
+        print("\nSet it in your .env file:")
+        print('MONGODB_URI="mongodb+srv://<user>:<pass>@<cluster>.mongodb.net/"')
+        sys.exit(1)
+
+    print("Connecting to MongoDB Atlas...")
+    print(f"Database: {db_name}")
+    print(f"Index name: {index_name}")
+    print()
+
+    try:
+        client = MongoClient(uri, serverSelectionTimeoutMS=5000)
+        # Test connection
+        client.admin.command("ping")
+        print("Connected successfully!\n")
+    except Exception as e:
+        print(f"Error: Failed to connect to MongoDB: {e}")
+        sys.exit(1)
+
+    db = client[db_name]
+    existing_collections = set(db.list_collection_names())
+
+    created_collections = []
+    created_indexes = []
+    existing_indexes = []
+    errors = []
+
+    for collection_name in RAG_COLLECTIONS:
+        print(f"Setting up: {collection_name}")
+
+        # Create collection if it doesn't exist
+        if collection_name not in existing_collections:
+            try:
+                db.create_collection(collection_name)
+                created_collections.append(collection_name)
+                print(" Created collection")
+            except Exception as e:
+                errors.append(f" Failed to create collection: {e}")
+                print(errors[-1])
+                continue
+        else:
+            print("  - Collection exists")
+
+        collection = db[collection_name]
+
+        # Check if index already exists
+        try:
+            existing = list(collection.list_search_indexes())
+            index_exists = any(idx.get("name") == index_name for idx in existing)
+
+            if index_exists:
+                print(f"  - Index '{index_name}' already exists")
+                existing_indexes.append(collection_name)
+                continue
+        except Exception:
+            # list_search_indexes might fail if no indexes exist
+            pass
+
+        # Create vector search index
+        try:
+            search_index = SearchIndexModel(
+                definition=VECTOR_INDEX_DEFINITION,
+                name=index_name,
+                type="vectorSearch",
+            )
+            collection.create_search_index(model=search_index)
+            created_indexes.append(collection_name)
+            print(f" Created vector index '{index_name}'")
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "already exists" in error_msg:
+                print(f"  - Index '{index_name}' already exists")
+                existing_indexes.append(collection_name)
+            else:
+                errors.append(f" Failed to create index: {e}")
+                print(errors[-1])
+
+    # Summary
+    print("\n" + "=" * 50)
+    print("SETUP COMPLETE")
+    print("=" * 50)
+
+    if created_collections:
+        print(f"\nCollections created ({len(created_collections)}):")
+        for name in created_collections:
+            print(f"  - {name}")
+
+    if created_indexes:
+        print(f"\nIndexes created ({len(created_indexes)}):")
+        for name in created_indexes:
+            print(f"  - {name}")
+        print("\nNote: Vector search indexes take 1-2 minutes to become active.")
+        print("Check status in Atlas UI: Database > Atlas Search")
+
+    if existing_indexes:
+        print(f"\nExisting indexes ({len(existing_indexes)}):")
+        for name in existing_indexes:
+            print(f"  - {name}")
+
+    if errors:
+        print(f"\nErrors ({len(errors)}):")
+        for err in errors:
+            print(err)
+
+    print()
+    client.close()
+
+
+def check_index_status() -> None:
+    """Check the status of vector search indexes."""
+    try:
+        from pymongo import MongoClient
+    except ImportError:
+        print("Error: pymongo not installed")
+        return
+
+    uri = os.getenv("MONGODB_URI")
+    db_name = os.getenv("MONGODB_DATABASE", "specs_before_code")
+    index_name = os.getenv("MONGODB_INDEX_NAME", "vector_index")
+
+    if not uri:
+        print("Error: MONGODB_URI not set")
+        return
+
+    client = MongoClient(uri)
+    db = client[db_name]
+
+    print(f"Checking index status in {db_name}...\n")
+
+    for collection_name in RAG_COLLECTIONS:
+        collection = db[collection_name]
+        try:
+            indexes = list(collection.list_search_indexes())
+            for idx in indexes:
+                if idx.get("name") == index_name:
+                    status = idx.get("status", "unknown")
+                    print(f"{collection_name}: {status}")
+                    break
+            else:
+                print(f"{collection_name}: no index")
+        except Exception as e:
+            print(f"{collection_name}: error - {e}")
+
+    client.close()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--status":
+        check_index_status()
+    else:
+        setup_indexes()

uv.lock

@@ -568,6 +568,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" },
 ]
 
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
 [[package]]
 name = "ecdsa"
 version = "0.19.1"
@@ -1032,6 +1041,38 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" },
 ]
 
+[[package]]
+name = "langchain"
+version = "1.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+    { name = "langgraph" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ed/3f/371267e88c153500a75c0e9daf9645a69955cfe6f85699955241ac0fa6e2/langchain-1.2.4.tar.gz", hash = "sha256:65119ff1c2ac8cc2410739b0fb2773f8fbfbe83357df9bab8a5fceafb9e04aa1", size = 552340, upload-time = "2026-01-14T19:35:26.556Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/71/667887579bb3cf3c2db88224849f7362a8c3f118666e426a51058ee43d9c/langchain-1.2.4-py3-none-any.whl", hash = "sha256:182ac9f3c4559c5a6477e00d60ff8a56212ec4db6f101a4957492818dc3ce3e9", size = 107949, upload-time = "2026-01-14T19:35:24.7Z" },
+]
+
+[[package]]
+name = "langchain-classic"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+    { name = "langchain-text-splitters" },
+    { name = "langsmith" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sqlalchemy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/4b/bd03518418ece4c13192a504449b58c28afee915dc4a6f4b02622458cb1b/langchain_classic-1.0.1.tar.gz", hash = "sha256:40a499684df36b005a1213735dc7f8dca8f5eb67978d6ec763e7a49780864fdc", size = 10516020, upload-time = "2025-12-23T22:55:22.615Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/0f/eab87f017d7fe28e8c11fff614f4cdbfae32baadb77d0f79e9f922af1df2/langchain_classic-1.0.1-py3-none-any.whl", hash = "sha256:131d83a02bb80044c68fedc1ab4ae885d5b8f8c2c742d8ab9e7534ad9cda8e80", size = 1040666, upload-time = "2025-12-23T22:55:21.025Z" },
+]
+
 [[package]]
 name = "langchain-core"
 version = "1.2.5"
@@ -1051,6 +1092,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/bd/9df897cbc98290bf71140104ee5b9777cf5291afb80333aa7da5a497339b/langchain_core-1.2.5-py3-none-any.whl", hash = "sha256:3255944ef4e21b2551facb319bfc426057a40247c0a05de5bd6f2fc021fbfa34", size = 484851, upload-time = "2025-12-22T23:45:30.525Z" },
 ]
 
+[[package]]
+name = "langchain-mongodb"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain" },
+    { name = "langchain-classic" },
+    { name = "langchain-core" },
+    { name = "langchain-text-splitters" },
+    { name = "lark" },
+    { name = "numpy" },
+    { name = "pymongo" },
+    { name = "pymongo-search-utils" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/0e/03027bbf0ae3ee71d00e32f5c64395cbee05393e6e5dc56e2d88320db542/langchain_mongodb-0.11.0.tar.gz", hash = "sha256:db483f12e8a4fdbbcfb0594881962fd1f0afcb38a3d42ee0d5fe8a2be20e1e86", size = 356447, upload-time = "2026-01-15T17:00:37.102Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/a1/a4ef0c7027166540a4aced056b1fd7194e4519932d2a846fd2cfd9f057cb/langchain_mongodb-0.11.0-py3-none-any.whl", hash = "sha256:7e1f43684c907d1f1fee4dbc480dd4909b3ebf03b5d3dad105ed9f4a4280d49f", size = 62037, upload-time = "2026-01-15T17:00:36.258Z" },
+]
+
 [[package]]
 name = "langchain-nvidia-ai-endpoints"
 version = "1.0.0"
@@ -1152,6 +1212,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ed/d8/91a8b483b30e0708a8911df10b4ce04ebf2b4b8dde8d020c124aec77380a/langsmith-0.5.2-py3-none-any.whl", hash = "sha256:42f8b853a18dd4d5f7fa38c8ff29e38da065a727022da410d91b3e13819aacc1", size = 283311, upload-time = "2025-12-30T13:41:33.915Z" },
 ]
 
+[[package]]
+name = "lark"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
+]
+
 [[package]]
 name = "libcst"
 version = "1.8.6"
@@ -1921,46 +1990,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload-time = "2025-10-15T18:23:57.149Z" },
 ]
 
-[[package]]
-name = "pinecone"
-version = "8.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "orjson" },
-    { name = "pinecone-plugin-assistant" },
-    { name = "pinecone-plugin-interface" },
-    { name = "python-dateutil" },
-    { name = "typing-extensions" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/33/13/f4c481a6a93dab92132d6d863b70a0e6c903f62940389435b31cf0c7d7d2/pinecone-8.0.0.tar.gz", hash = "sha256:feca7ff607706c09ffbd127ec93fa3b7110896b30c0d7a57672da73c69698d53", size = 1092653, upload-time = "2025-11-18T18:21:30.584Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/6c/1d870a9211eb8f0bf60214182de001b480f94590eca9d6164a5d6d7de031/pinecone-8.0.0-py3-none-any.whl", hash = "sha256:95f714a496a91d80f3405165aedfea76ca8ac16e51e618df0434241838e353f8", size = 745902, upload-time = "2025-11-18T18:21:25.584Z" },
-]
-
-[[package]]
-name = "pinecone-plugin-assistant"
-version = "3.0.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "packaging" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/08/1a/33249870c9e8c774dafc038419b48aa63b380b461e9a1c1cb042db31be49/pinecone_plugin_assistant-3.0.1.tar.gz", hash = "sha256:6b00e94ef1bf55ed601d2316ee6f71f96f93bf2155277a826638395e1090dde3", size = 152060, upload-time = "2025-11-11T07:45:07.224Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/88/4b801675b4d58c5f8acd96bfd4847e6d7bc1a93ee4ff916e913dd6bda2de/pinecone_plugin_assistant-3.0.1-py3-none-any.whl", hash = "sha256:cd86ca5c98137221170e90fe81e03bbe71999992096da68c77f4af3503017622", size = 280865, upload-time = "2025-11-11T07:45:06.055Z" },
-]
-
-[[package]]
-name = "pinecone-plugin-interface"
-version = "0.0.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f4/fb/e8a4063264953ead9e2b24d9b390152c60f042c951c47f4592e9996e57ff/pinecone_plugin_interface-0.0.7.tar.gz", hash = "sha256:b8e6675e41847333aa13923cc44daa3f85676d7157324682dc1640588a982846", size = 3370, upload-time = "2024-06-05T01:57:52.093Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/1d/a21fdfcd6d022cb64cef5c2a29ee6691c6c103c4566b41646b080b7536a5/pinecone_plugin_interface-0.0.7-py3-none-any.whl", hash = "sha256:875857ad9c9fc8bbc074dbe780d187a2afd21f5bfe0f3b08601924a61ef1bba8", size = 6249, upload-time = "2024-06-05T01:57:50.583Z" },
-]
-
 [[package]]
 name = "platformdirs"
 version = "4.5.1"
@@ -2256,6 +2285,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]
 
+[[package]]
+name = "pymongo"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/9c/a4895c4b785fc9865a84a56e14b5bd21ca75aadc3dab79c14187cdca189b/pymongo-4.16.0.tar.gz", hash = "sha256:8ba8405065f6e258a6f872fe62d797a28f383a12178c7153c01ed04e845c600c", size = 2495323, upload-time = "2026-01-07T18:05:48.107Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/03/6dd7c53cbde98de469a3e6fb893af896dca644c476beb0f0c6342bcc368b/pymongo-4.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bd4911c40a43a821dfd93038ac824b756b6e703e26e951718522d29f6eb166a8", size = 917619, upload-time = "2026-01-07T18:04:19.173Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e1/328915f2734ea1f355dc9b0e98505ff670f5fab8be5e951d6ed70971c6aa/pymongo-4.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25a6b03a68f9907ea6ec8bc7cf4c58a1b51a18e23394f962a6402f8e46d41211", size = 917364, upload-time = "2026-01-07T18:04:20.861Z" },
+    { url = "https://files.pythonhosted.org/packages/41/fe/4769874dd9812a1bc2880a9785e61eba5340da966af888dd430392790ae0/pymongo-4.16.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:91ac0cb0fe2bf17616c2039dac88d7c9a5088f5cb5829b27c9d250e053664d31", size = 1686901, upload-time = "2026-01-07T18:04:22.219Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/8d/15707b9669fdc517bbc552ac60da7124dafe7ac1552819b51e97ed4038b4/pymongo-4.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf0ec79e8ca7077f455d14d915d629385153b6a11abc0b93283ed73a8013e376", size = 1723034, upload-time = "2026-01-07T18:04:24.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/af/3d5d16ff11d447d40c1472da1b366a31c7380d7ea2922a449c7f7f495567/pymongo-4.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2d0082631a7510318befc2b4fdab140481eb4b9dd62d9245e042157085da2a70", size = 1797161, upload-time = "2026-01-07T18:04:25.964Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/04/725ab8664eeec73ec125b5a873448d80f5d8cf2750aaaf804cbc538a50a5/pymongo-4.16.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85dc2f3444c346ea019a371e321ac868a4fab513b7a55fe368f0cc78de8177cc", size = 1780938, upload-time = "2026-01-07T18:04:28.745Z" },
+    { url = "https://files.pythonhosted.org/packages/22/50/dd7e9095e1ca35f93c3c844c92eb6eb0bc491caeb2c9bff3b32fe3c9b18f/pymongo-4.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dabbf3c14de75a20cc3c30bf0c6527157224a93dfb605838eabb1a2ee3be008d", size = 1714342, upload-time = "2026-01-07T18:04:30.331Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c9/542776987d5c31ae8e93e92680ea2b6e5a2295f398b25756234cabf38a39/pymongo-4.16.0-cp312-cp312-win32.whl", hash = "sha256:60307bb91e0ab44e560fe3a211087748b2b5f3e31f403baf41f5b7b0a70bd104", size = 887868, upload-time = "2026-01-07T18:04:32.124Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d4/b4045a7ccc5680fb496d01edf749c7a9367cc8762fbdf7516cf807ef679b/pymongo-4.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:f513b2c6c0d5c491f478422f6b5b5c27ac1af06a54c93ef8631806f7231bd92e", size = 907554, upload-time = "2026-01-07T18:04:33.685Z" },
+    { url = "https://files.pythonhosted.org/packages/60/4c/33f75713d50d5247f2258405142c0318ff32c6f8976171c4fcae87a9dbdf/pymongo-4.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:dfc320f08ea9a7ec5b2403dc4e8150636f0d6150f4b9792faaae539c88e7db3b", size = 892971, upload-time = "2026-01-07T18:04:35.594Z" },
+    { url = "https://files.pythonhosted.org/packages/47/84/148d8b5da8260f4679d6665196ae04ab14ffdf06f5fe670b0ab11942951f/pymongo-4.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d15f060bc6d0964a8bb70aba8f0cb6d11ae99715438f640cff11bbcf172eb0e8", size = 972009, upload-time = "2026-01-07T18:04:38.303Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/5e/9f3a8daf583d0adaaa033a3e3e58194d2282737dc164014ff33c7a081103/pymongo-4.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a19ea46a0fe71248965305a020bc076a163311aefbaa1d83e47d06fa30ac747", size = 971784, upload-time = "2026-01-07T18:04:39.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/f2/b6c24361fcde24946198573c0176406bfd5f7b8538335f3d939487055322/pymongo-4.16.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:311d4549d6bf1f8c61d025965aebb5ba29d1481dc6471693ab91610aaffbc0eb", size = 1947174, upload-time = "2026-01-07T18:04:41.368Z" },
+    { url = "https://files.pythonhosted.org/packages/47/1a/8634192f98cf740b3d174e1018dd0350018607d5bd8ac35a666dc49c732b/pymongo-4.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46ffb728d92dd5b09fc034ed91acf5595657c7ca17d4cf3751322cd554153c17", size = 1991727, upload-time = "2026-01-07T18:04:42.965Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/2f/0c47ac84572b28e23028a23a3798a1f725e1c23b0cf1c1424678d16aff42/pymongo-4.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:acda193f440dd88c2023cb00aa8bd7b93a9df59978306d14d87a8b12fe426b05", size = 2082497, upload-time = "2026-01-07T18:04:44.652Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/57/9f46ef9c862b2f0cf5ce798f3541c201c574128d31ded407ba4b3918d7b6/pymongo-4.16.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d9fdb386cf958e6ef6ff537d6149be7edb76c3268cd6833e6c36aa447e4443f", size = 2064947, upload-time = "2026-01-07T18:04:46.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/5421c0998f38e32288100a07f6cb2f5f9f352522157c901910cb2927e211/pymongo-4.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91899dd7fb9a8c50f09c3c1cf0cb73bfbe2737f511f641f19b9650deb61c00ca", size = 1980478, upload-time = "2026-01-07T18:04:48.017Z" },
+    { url = "https://files.pythonhosted.org/packages/92/93/bfc448d025e12313a937d6e1e0101b50cc9751636b4b170e600fe3203063/pymongo-4.16.0-cp313-cp313-win32.whl", hash = "sha256:2cd60cd1e05de7f01927f8e25ca26b3ea2c09de8723241e5d3bcfdc70eaff76b", size = 934672, upload-time = "2026-01-07T18:04:49.538Z" },
+    { url = "https://files.pythonhosted.org/packages/96/10/12710a5e01218d50c3dd165fd72c5ed2699285f77348a3b1a119a191d826/pymongo-4.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3ead8a0050c53eaa55935895d6919d393d0328ec24b2b9115bdbe881aa222673", size = 959237, upload-time = "2026-01-07T18:04:51.382Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/56/d288bcd1d05bc17ec69df1d0b1d67bc710c7c5dbef86033a5a4d2e2b08e6/pymongo-4.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:dbbc5b254c36c37d10abb50e899bc3939bbb7ab1e7c659614409af99bd3e7675", size = 940909, upload-time = "2026-01-07T18:04:52.904Z" },
+    { url = "https://files.pythonhosted.org/packages/30/9e/4d343f8d0512002fce17915a89477b9f916bda1205729e042d8f23acf194/pymongo-4.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:8a254d49a9ffe9d7f888e3c677eed3729b14ce85abb08cd74732cead6ccc3c66", size = 1026634, upload-time = "2026-01-07T18:04:54.359Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/e3/341f88c5535df40c0450fda915f582757bb7d988cdfc92990a5e27c4c324/pymongo-4.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a1bf44e13cf2d44d2ea2e928a8140d5d667304abe1a61c4d55b4906f389fbe64", size = 1026252, upload-time = "2026-01-07T18:04:56.642Z" },
+    { url = "https://files.pythonhosted.org/packages/af/64/9471b22eb98f0a2ca0b8e09393de048502111b2b5b14ab1bd9e39708aab5/pymongo-4.16.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f1c5f1f818b669875d191323a48912d3fcd2e4906410e8297bb09ac50c4d5ccc", size = 2207399, upload-time = "2026-01-07T18:04:58.255Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ac/47c4d50b25a02f21764f140295a2efaa583ee7f17992a5e5fa542b3a690f/pymongo-4.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77cfd37a43a53b02b7bd930457c7994c924ad8bbe8dff91817904bcbf291b371", size = 2260595, upload-time = "2026-01-07T18:04:59.788Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/1b/0ce1ce9dd036417646b2fe6f63b58127acff3cf96eeb630c34ec9cd675ff/pymongo-4.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:36ef2fee50eee669587d742fb456e349634b4fcf8926208766078b089054b24b", size = 2366958, upload-time = "2026-01-07T18:05:01.942Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/3c/a5a17c0d413aa9d6c17bc35c2b472e9e79cda8068ba8e93433b5f43028e9/pymongo-4.16.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55f8d5a6fe2fa0b823674db2293f92d74cd5f970bc0360f409a1fc21003862d3", size = 2346081, upload-time = "2026-01-07T18:05:03.576Z" },
+    { url = "https://files.pythonhosted.org/packages/65/19/f815533d1a88fb8a3b6c6e895bb085ffdae68ccb1e6ed7102202a307f8e2/pymongo-4.16.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9caacac0dd105e2555521002e2d17afc08665187017b466b5753e84c016628e6", size = 2246053, upload-time = "2026-01-07T18:05:05.459Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/88/4be3ec78828dc64b212c123114bd6ae8db5b7676085a7b43cc75d0131bd2/pymongo-4.16.0-cp314-cp314-win32.whl", hash = "sha256:c789236366525c3ee3cd6e4e450a9ff629a7d1f4d88b8e18a0aea0615fd7ecf8", size = 989461, upload-time = "2026-01-07T18:05:07.018Z" },
+    { url = "https://files.pythonhosted.org/packages/af/5a/ab8d5af76421b34db483c9c8ebc3a2199fb80ae63dc7e18f4cf1df46306a/pymongo-4.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:2b0714d7764efb29bf9d3c51c964aed7c4c7237b341f9346f15ceaf8321fdb35", size = 1017803, upload-time = "2026-01-07T18:05:08.499Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f4/98d68020728ac6423cf02d17cfd8226bf6cce5690b163d30d3f705e8297e/pymongo-4.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:12762e7cc0f8374a8cae3b9f9ed8dabb5d438c7b33329232dd9b7de783454033", size = 997184, upload-time = "2026-01-07T18:05:09.944Z" },
+    { url = "https://files.pythonhosted.org/packages/50/00/dc3a271daf06401825b9c1f4f76f018182c7738281ea54b9762aea0560c1/pymongo-4.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1c01e8a7cd0ea66baf64a118005535ab5bf9f9eb63a1b50ac3935dccf9a54abe", size = 1083303, upload-time = "2026-01-07T18:05:11.702Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4b/b5375ee21d12eababe46215011ebc63801c0d2c5ffdf203849d0d79f9852/pymongo-4.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4c4872299ebe315a79f7f922051061634a64fda95b6b17677ba57ef00b2ba2a4", size = 1083233, upload-time = "2026-01-07T18:05:13.182Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/e3/52efa3ca900622c7dcb56c5e70f15c906816d98905c22d2ee1f84d9a7b60/pymongo-4.16.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:78037d02389745e247fe5ab0bcad5d1ab30726eaac3ad79219c7d6bbb07eec53", size = 2527438, upload-time = "2026-01-07T18:05:14.981Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/96/43b1be151c734e7766c725444bcbfa1de6b60cc66bfb406203746839dd25/pymongo-4.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c126fb72be2518395cc0465d4bae03125119136462e1945aea19840e45d89cfc", size = 2600399, upload-time = "2026-01-07T18:05:16.794Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/62/fa64a5045dfe3a1cd9217232c848256e7bc0136cffb7da4735c5e0d30e40/pymongo-4.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f3867dc225d9423c245a51eaac2cfcd53dde8e0a8d8090bb6aed6e31bd6c2d4f", size = 2720960, upload-time = "2026-01-07T18:05:18.498Z" },
+    { url = "https://files.pythonhosted.org/packages/54/7b/01577eb97e605502821273a5bc16ce0fb0be5c978fe03acdbff471471202/pymongo-4.16.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f25001a955073b80510c0c3db0e043dbbc36904fd69e511c74e3d8640b8a5111", size = 2699344, upload-time = "2026-01-07T18:05:20.073Z" },
+    { url = "https://files.pythonhosted.org/packages/55/68/6ef6372d516f703479c3b6cbbc45a5afd307173b1cbaccd724e23919bb1a/pymongo-4.16.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d9885aad05f82fd7ea0c9ca505d60939746b39263fa273d0125170da8f59098", size = 2577133, upload-time = "2026-01-07T18:05:22.052Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c7/b5337093bb01da852f945802328665f85f8109dbe91d81ea2afe5ff059b9/pymongo-4.16.0-cp314-cp314t-win32.whl", hash = "sha256:948152b30eddeae8355495f9943a3bf66b708295c0b9b6f467de1c620f215487", size = 1040560, upload-time = "2026-01-07T18:05:23.888Z" },
+    { url = "https://files.pythonhosted.org/packages/96/8c/5b448cd1b103f3889d5713dda37304c81020ff88e38a826e8a75ddff4610/pymongo-4.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f6e42c1bc985d9beee884780ae6048790eb4cd565c46251932906bdb1630034a", size = 1075081, upload-time = "2026-01-07T18:05:26.874Z" },
+    { url = "https://files.pythonhosted.org/packages/32/cd/ddc794cdc8500f6f28c119c624252fb6dfb19481c6d7ed150f13cf468a6d/pymongo-4.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6b2a20edb5452ac8daa395890eeb076c570790dfce6b7a44d788af74c2f8cf96", size = 1047725, upload-time = "2026-01-07T18:05:28.47Z" },
+]
+
+[[package]]
+name = "pymongo-search-utils"
+version = "0.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pymongo" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/aa/3eb266ffc74ec52bbf6dd92d311ab4fc3225c2ac8f1a2e6abe98f7288867/pymongo_search_utils-0.3.0.tar.gz", hash = "sha256:56148987ce9ff191eb1cd0f56c01d3dae497a3cb6d7b7db75ec894a9afcbe418", size = 13728, upload-time = "2026-02-03T22:18:24.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/ed/87d3ed0e45b9230bacb9edcb913d515e6756bc2df3384e5f192662c38ce8/pymongo_search_utils-0.3.0-py3-none-any.whl", hash = "sha256:9b9ef8dfbd57da530ce7c2bde10aec8f462605080a9ed4e9a41679170c8742bf", size = 19467, upload-time = "2026-02-03T22:18:23.398Z" },
+]
+
 [[package]]
 name = "pyparsing"
 version = "3.3.1"
@@ -2308,18 +2400,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
 ]
 
-[[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
-]
-
 [[package]]
 name = "python-dotenv"
 version = "1.2.1"
@@ -2565,6 +2645,7 @@ dependencies = [
     { name = "hydra-core" },
     { name = "jinja2" },
     { name = "langchain-core" },
+    { name = "langchain-mongodb" },
     { name = "langchain-nvidia-ai-endpoints" },
     { name = "langchain-text-splitters" },
     { name = "langgraph" },
@@ -2572,9 +2653,9 @@ dependencies = [
     { name = "lightning" },
     { name = "numpy" },
     { name = "passlib", extra = ["bcrypt"] },
-    { name = "pinecone" },
     { name = "psycopg2-binary" },
     { name = "pydantic" },
+    { name = "pymongo" },
     { name = "python-dotenv" },
     { name = "python-jose", extra = ["cryptography"] },
     { name = "python-multipart" },
@@ -2618,6 +2699,7 @@ requires-dist = [
     { name = "hydra-core", specifier = ">=1.3.2" },
     { name = "jinja2", specifier = ">=3.1.6" },
     { name = "langchain-core", specifier = ">=0.1.0" },
+    { name = "langchain-mongodb", specifier = ">=0.1.0" },
     { name = "langchain-nvidia-ai-endpoints", specifier = ">=1.0.0" },
     { name = "langchain-text-splitters", specifier = ">=0.0.1" },
     { name = "langgraph", specifier = ">=0.2.39" },
@@ -2626,9 +2708,9 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.10.0" },
     { name = "numpy", specifier = ">=1.26.0" },
     { name = "passlib", extras = ["bcrypt"], specifier = ">=1.7.4" },
-    { name = "pinecone" },
     { name = "psycopg2-binary", specifier = ">=2.9.9" },
     { name = "pydantic", specifier = ">=2.7.0" },
+    { name = "pymongo", specifier = ">=4.6.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.23.0" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" },