Upload 5 files

src/__init__.py

@@ -0,0 +1,5 @@
+from .docparser import DocParser
+from .chunkers import Chunker, SemanticChunker, AgenticChunker
+from .imageprocessing import ImageProcessor
+from .doc_qa import AgenticQA
+from src.indexing import indexing

src/doc_qa.py

@@ -0,0 +1,751 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_classic import hub
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_classic.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.tools import Tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.retrievers import BM25Retriever
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_classic.agents import AgentExecutor, create_react_agent
+from langchain_core.documents import Document
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_chroma import Chroma
+from langchain_core.agents import AgentAction
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from flashrank import Ranker, RerankRequest
+from src.metrics_tracker import MetricsTracker
+import logging
+
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+class ContextRetriever:
+    def __init__(self, retriever):
+        self.retriever = retriever
+
+    def deduplicate_context(self, context_list): 
+        """Deduplicate context entries to avoid repetition."""
+        seen = set()
+        deduped = []
+        for item in context_list:
+            if item not in seen:
+                seen.add(item)
+                deduped.append(item)
+        return "\n".join(deduped) if deduped else "No relevant context found."
+
+    def retrieve(self, query, top_k=5):
+        """
+        Retrieve the top-k relevant contexts from ChromaDB based on the query.
+        
+        Args:
+            query (str): The query or prediction to search for.
+            top_k (int): Number of top results to return (default: 3).
+        
+        Returns:
+            str: Deduplicated context string from the top-k results.
+        """
+        logger.info(f"Retrieving for query: {query}")
+        try:
+            # Perform similarity search using ChromaDB retriever
+            results = self.retriever.invoke(query, k=top_k) 
+            logger.info(f"Retrieved documents: {[doc.metadata.get('source') for doc in results]}")
+            
+            # Extract the page content (context) from each result
+            contexts = [doc.page_content for doc in results]
+            logger.info(f"Context : {contexts}")
+            
+            # Deduplicate the contexts
+            deduped_context = self.deduplicate_context(contexts)
+            logger.info(f"Deduplicated context: {deduped_context}")
+            
+            return deduped_context
+        except Exception as e:
+            logger.error(f"Retrieval error: {str(e)}")
+            return "Retrieval failed due to error."
+
+class LLMComplexityAnalyzer:
+    """
+    Analyzes query complexity using an LLM to make a "managerial" decision
+    on the optimal retrieval strategy.
+    """
+    
+    def __init__(self, domain: str, llm: ChatGoogleGenerativeAI):
+        self.domain = domain
+        self.llm = llm
+        
+        self.system_prompt = (
+            "You are a 'Complexity Analyzer' manager for a RAG (Retrieval-Augmented Generation) system. "
+            "Your domain of expertise is: **{domain}**."
+            "\n"
+            "Your task is to analyze the user's query and determine its complexity. Based on this, "
+            "you will decide how many documents (k) to retrieve. More complex queries require "
+            "more documents to synthesize a good answer."
+            "\n"
+            "Here are the retrieval strategies:"
+            "1.  **simple**: For simple, direct fact-finding queries. (e.g., 'What is takaful?') "
+            "    - Set k = 5"
+            "2.  **moderate**: For queries that require explanation, some comparison, or have multiple parts. "
+            "    (e.g., 'What is the difference between madhab Shafi'i and Maliki on prayer?') "
+            "    - Set k = 10"
+            "3.  **complex**: For deep, nuanced, multi-step, or highly comparative/synthetic queries. "
+            "    (e.g., 'Explain in detail the treatment options for type 2 diabetes, comparing "
+            "    their side effects and suitability for elderly patients.')"
+            "    - Set k = 15"
+            "\n"
+            "Analyze the following query and provide your reasoning."
+            "\n"
+            "**IMPORTANT**: You MUST respond ONLY with a single, valid JSON object. Do not add any "
+            "other text. The JSON object must have these three keys:"
+            "-   `complexity`: (string) Must be one of 'simple', 'moderate', or 'complex'."
+            "-   `k`: (integer) Must be 5, 10, or 15, corresponding to the complexity."
+            "-   `reasoning`: (string) A brief 1-sentence explanation for your decision."
+        )
+        
+        self.prompt_template = ChatPromptTemplate.from_messages([
+            ("system", self.system_prompt.format(domain=self.domain)),
+            ("human", "{query}")
+        ])
+        
+        self.output_parser = JsonOutputParser()
+        
+        # This chain will output a parsed dictionary
+        self.chain = self.prompt_template | self.llm | self.output_parser
+        
+        logger.info(f"🧠 LLMComplexityAnalyzer initialized for '{self.domain}'")
+
+    def analyze(self, query: str) -> dict:
+        """
+        Analyzes query complexity using an LLM and returns the retrieval strategy.
+        """
+        logger.info(f"🧠 LLMComplexityAnalyzer: Analyzing query...")
+        
+        try:
+            # Invoke the chain to get the structured JSON output
+            result = self.chain.invoke({"query": query})
+            
+            # Add a 'score' field for compatibility
+            score_map = {"simple": 2, "moderate": 4, "complex": 6}
+            result['score'] = score_map.get(result.get('complexity'), 0)
+                
+            logger.info(f"🧠 LLM Decision: {result.get('complexity').upper()} (k={result.get('k')})")
+            logger.info(f"   Reasoning: {result.get('reasoning')}")
+            
+            return result
+            
+        except Exception as e:
+            # Fallback in case the LLM fails or returns bad JSON
+            logger.error(f"❌ LLMComplexityAnalyzer failed: {e}. Defaulting to 'moderate' strategy.")
+            return {
+                "complexity": "moderate",
+                "k": 12,
+                "score": 4,
+                "reasoning": "Fallback: LLM analysis or JSON parsing failed."
+            }
+
+
+class SwarmRetriever:
+    """
+    Multi-retriever swarm that executes parallel retrieval strategies.
+    Worker component that takes orders from LLMComplexityAnalyzer.
+    """
+    
+    def __init__(self, chroma_retriever, documents):
+        self.dense_retriever = chroma_retriever  # Semantic search
+        self.bm25_retriever = BM25Retriever.from_documents(documents)  # Keyword search
+        self.bm25_retriever.k = 20  # Set high, will be limited by k parameter
+        logger.info("✅ SwarmRetriever initialized (Dense + BM25 workers)")
+    
+    def retrieve_with_swarm(self, query: str, k: int) -> list:
+        """
+        Execute multi-retriever swarm with parallel workers.
+        """
+        logger.info(f"🐝 Swarm deployment: {2} workers, target k={k}")
+        
+        # Define worker tasks
+        retrieval_tasks = {
+            "dense_semantic": lambda: self.dense_retriever.invoke(query, k=k),
+            "bm25_keyword": lambda: self.bm25_retriever.invoke(query)[:k],
+        }
+        
+        # Execute workers in parallel
+        swarm_results = {}
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            futures = {
+                executor.submit(task): name 
+                for name, task in retrieval_tasks.items()
+            }
+            
+            for future in as_completed(futures):
+                worker_name = futures[future]
+                try:
+                    results = future.result()
+                    swarm_results[worker_name] = results
+                    logger.info(f"  ✅ Worker '{worker_name}': {len(results)} docs")
+                except Exception as e:
+                    logger.error(f"  ❌ Worker '{worker_name}' failed: {e}")
+                    swarm_results[worker_name] = []
+        
+        # Combine and deduplicate documents
+        combined_docs = self._combine_and_deduplicate(swarm_results)
+        
+        return combined_docs
+    
+    def _combine_and_deduplicate(self, swarm_results: dict) -> list:
+        """Combine results from all workers and remove duplicates."""
+        all_docs = []
+        seen_content = set()
+        worker_contributions = {}
+        
+        for worker_name, docs in swarm_results.items():
+            for doc in docs:
+                # Use first 200 chars as hash to detect duplicates
+                content_hash = hash(doc.page_content[:200])
+                
+                if content_hash not in seen_content:
+                    seen_content.add(content_hash)
+                    
+                    # Tag document with source worker
+                    doc.metadata['swarm_worker'] = worker_name
+                    all_docs.append(doc)
+                    
+                    # Track contributions
+                    worker_contributions[worker_name] = \
+                        worker_contributions.get(worker_name, 0) + 1
+        
+        logger.info(f"🐝 Swarm combined: {len(all_docs)} unique docs")
+        logger.info(f"   Worker contributions: {worker_contributions}")
+        
+        return all_docs
+    
+class AgenticQA:
+    def __init__(self, config=None):  
+        logger.info("Initializing AgenticQA...")
+        
+        # Load a small, fast reranker model. This runs locally.
+        try:
+            self.reranker = Ranker(model_name="ms-marco-MiniLM-L-12-v2")
+            logger.info("FlashRank Reranker loaded successfully.")
+        except Exception as e:
+            logger.error(f"Failed to load FlashRank reranker: {e}")
+            self.reranker = None
+        
+        self.contextualize_q_system_prompt = (
+            "Given a chat history and the latest user question which might reference context in the chat history, "
+            "formulate a standalone question which can be understood without the chat history. "
+            "IMPORTANT: DO NOT provide any answers or explanations. ONLY rephrase the question if needed. "
+            "If the question is already clear and standalone, return it exactly as is. "
+            "Output ONLY the reformulated question, nothing else."
+        )
+        
+        self.contextualize_q_prompt = ChatPromptTemplate.from_messages(
+            [("system", self.contextualize_q_system_prompt),
+             MessagesPlaceholder("chat_history"),
+             ("human", "{input}")]
+        )
+        self.qa_system_prompt = (
+            "You are an assistant that answers questions in a specific domain for citizens mainly in Malaysia, "
+            "depending on the context. "
+            "You will receive:\n"
+            "  • domain = {domain}  (either 'medical', 'islamic' , or 'insurance')\n"
+            "  • context = relevant retrieved passages\n"
+            "  • user question\n\n"
+            "If the context does not contain the answer, **YOU MUST SAY 'I do not know'** or 'I cannot find that information in the provided documents.' Do not use your general knowledge.\n\n"
+            "Instructions based on domain:\n"
+            "1. If domain = 'medical' :\n"
+            "   - Answer the question in clear, simple layperson language, "
+            "   - Citing your sources (e.g. article name, section)."
+            "   - Add a medical disclaimer: “I am not a doctor…”.\n"
+            "2. If domain = 'islamic':\n"
+            "   - **ALWAYS present both Shafi'i AND Maliki perspectives** if the question is about fiqh/rulings\n"
+            "   - **Cite specific sources**: Always mention the book name (e.g., 'According to Muwatta Imam Malik...', 'Minhaj al-Talibin states...', 'Umdat al-Salik explains...')\n"
+            "   - **Structure answer as**:\n" 
+            "      - Shafi'i view (from Umdat al-Salik/Minhaj): [ruling with citation]\n"
+            "      - Maliki view (from Muwatta): [ruling with citation]\n"
+            "      - If they agree: mention the consensus\n"
+            "      - If they differ: present both views objectively without favoring one\n"
+            "   - **For hadith questions**: provide the narration text, source (book name, hadith number)\n "
+            "   - - **If ruling has EXCEPTIONS** (like 'except for...', 'unless...'), YOU MUST include them. "
+            "      If context doesn't show exceptions but the ruling seems absolute, indicate this uncertainty.\n"
+            "   - If the context does not contain relevant information from BOTH madhabs, acknowledge which sources you have "
+            "      (e.g., 'Based on Shafi'i sources only...') and suggest consulting additional madhab resources.\n"
+            "   - **Always end with**: 'This is not a fatwa. Consult a local scholar for guidance specific to your situation.'\n"
+            "   - Always include hadith narration or quran verse as evidence (if it exists) in the final response "
+            "   - Keep answers concise but comprehensive enough to show different scholarly views.\n\n"
+            
+            "3. If domain = 'insurance':\n"
+            "   - Your knowledge is STRICTLY limited to Etiqa Takaful (Motor and Car policies).\n"
+            "   - First, try to answer ONLY using the provided <context>.\n"
+            "   - **If the answer is not in the context, YOU MUST SAY 'I do not have information on that specific topic.'** Do not make up an answer.\n"
+            "   - If the user asks about other Etiqa products (e.g., medical, travel), you MUST use the 'EtiqaWebSearch' tool.\n"
+            "   - If the user asks about another insurance company (e.g., 'Prudential', 'Takaful Ikhlas'), state that you can only answer about Etiqa Takaful.\n"
+            "   - If the user asks a general insurance question (e.g., 'What is takaful?', 'What is an excess?'), use the 'GeneralWebSearch' tool.\n"
+                    
+            "4. For ALL domains: If the context does not contain the answer, do not make one up. Be honest.\n\n"
+            "Context:\n"
+            "{context}"
+            )
+
+        self.qa_prompt = ChatPromptTemplate.from_messages(
+            [("system", self.qa_system_prompt),
+             MessagesPlaceholder("chat_history"),
+             ("human", "{input}")]
+        )
+        self.llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash",temperature=0.05) 
+        # --- START: NEW QUERY REFINER ---
+        self.refiner_system_prompt = (
+            "You are an expert search query refiner. Your task is to take a user's question "
+            "and rewrite it to be a perfect, concise search query for a database. "
+            "Remove all conversational fluff, emotion, and filler words. "
+            "Distill the query to its core semantic intent. "
+            "For example:"
+            "- 'Hi, I was wondering if I can touch a dog if I found it is cute?' becomes 'ruling on touching a dog in islam'"
+            "- 'What are the treatments for, like, a common cold?' becomes 'common cold treatment options'"
+            "- 'Tell me about diabetes' becomes 'what is diabetes'"
+            "Output ONLY the refined query, nothing else."
+        )
+        
+        self.refiner_prompt = ChatPromptTemplate.from_messages([
+            ("system", self.refiner_system_prompt),
+            ("human", "{query}")
+        ])
+        
+        self.refiner_chain = self.refiner_prompt | self.llm
+        logger.info("✅ Query Refiner chain initialized.")
+        # --- END: NEW QUERY REFINER ---
+
+        self.react_docstore_prompt = hub.pull("aallali/react_tool_priority")
+        self.answer_validator = AnswerValidatorAgent(self.llm)
+
+        self.retriever = None
+        self.agent_executor = None
+        self.tools = [] # Initialize the attribute
+        self.domain = "general"
+        self.answer_validator = None
+        self.retrieval_agent = None
+
+        if config:
+            logger.info(f"Configuring AgenticQA with provided config: {config}")
+            try:
+                collection_name = config["retriever"]["collection_name"]
+                persist_directory = config["retriever"]["persist_directory"]
+                self.domain = config.get("domain", "general") # Get domain from config
+                
+                # 1. Initialize the embedding function
+                embedding_function = GoogleGenerativeAIEmbeddings(model="models/text-embedding-004")
+
+                # 2. Connect to the persistent ChromaDB
+                db_client = Chroma(
+                    persist_directory=persist_directory,
+                    embedding_function=embedding_function,
+                    collection_name=collection_name
+                )
+
+                # 3. Set the retriever for this instance
+                self.retriever = db_client.as_retriever()
+                logger.info(f"✅ Successfully created retriever for collection '{collection_name}'")
+                # --- START: NEW SWARM INITIALIZATION ---
+                logger.info("Initializing Swarm components...")
+                # Get all documents from Chroma for BM25
+                all_docs_data = db_client.get()
+                docs_for_bm25 = [
+                    Document(page_content=content, metadata=meta)
+                    for content, meta in zip(
+                        all_docs_data['documents'], 
+                        all_docs_data['metadatas']
+                    )
+                ]
+                
+                # Initialize SwarmRetriever (Workers)
+                self.swarm_retriever = SwarmRetriever(self.retriever, docs_for_bm25)
+                
+                # Initialize LLMComplexityAnalyzer (Manager)
+                self.complexity_analyzer = LLMComplexityAnalyzer(self.domain, self.llm)
+                logger.info("✅ Swarm components (Manager + Workers) initialized.")
+                # --- END: NEW SWARM INITIALIZATION ---
+                self.metrics_tracker = MetricsTracker(save_path=f"metrics_{self.domain}.json")
+                logger.info("✅ Metrics tracker initialized")
+                # Initialize validator *after* setting domain
+                self.answer_validator = AnswerValidatorAgent(self.llm, self.domain)
+                 # --- This is the new, simple QA chain that will be used *after* reranking ---
+                self.qa_chain = create_stuff_documents_chain(self.llm, self.qa_prompt)
+
+                self._initialize_agent()
+                
+            except Exception as e:
+                logger.error(f"❌ Error during AgenticQA setup for '{self.domain}': {e}", exc_info=True)
+        else:
+            logger.warning("⚠️ AgenticQA initialized without a config. Retriever will be None.")
+
+    # --- 5. NEW UPGRADED RAG FUNCTION ---
+    # This is our new, smarter "worker" function that includes the reranker.
+    def _run_rag_with_reranking(self, query: str, chat_history: list) -> str:
+        """
+        Enhanced Swarm-RAG pipeline with adaptive retrieval and reranking.
+        
+        Pipeline:
+        1. Contextualize query
+        2. Refine query
+        3. ComplexityAnalyzer (Manager) determines optimal k
+        4. SwarmRetriever (Workers) deploys parallel retrievers with k
+        5. Rerank combined swarm results
+        6. Filter results by threshold
+        7. Generate Answer
+        """
+        logger.info(f"--- 🐝 SWARM RAG (with Reranker) PIPELINE RUNNING for query: '{query}' ---")
+        
+        if not self.reranker or not self.swarm_retriever or not self.complexity_analyzer:
+            logger.error("Swarm components or Reranker not initialized. Cannot perform RAG.")
+            return "Error: RAG components are not available."
+
+        try:
+            # 1. Contextualize query
+            standalone_query = query
+            if chat_history:
+                contextualize_chain = self.contextualize_q_prompt | self.llm
+                response = contextualize_chain.invoke({"chat_history": chat_history, "input": query})
+                standalone_query = response.content
+                logger.info(f"Contextualized query: '{standalone_query}'")
+            
+            # 2 - REFINE QUERY ---
+            logger.info("Refining query for search...")
+            response = self.refiner_chain.invoke({"query": standalone_query})
+            refined_query = response.content.strip()
+            logger.info(f"Refined query: '{refined_query}'")
+            
+            
+            # 3. Complexity analysis
+            analysis = self.complexity_analyzer.analyze(standalone_query)
+            k = analysis['k']
+            self._last_complexity_analysis = analysis
+            logger.info(f"Query complexity: {analysis['complexity'].upper()} | k={k}")
+            
+            # 4. Retrieve with Swarm (Workers)
+            swarm_docs = self.swarm_retriever.retrieve_with_swarm(standalone_query, k=k)
+            
+            if not swarm_docs:
+                logger.warning("Swarm Retriever found no documents.")
+                return "I do not know the answer to that as it is not in my documents."
+            
+            # 5. Format for Reranker
+            passages = [
+                {"id": i, "text": doc.page_content, "meta": doc.metadata} 
+                for i, doc in enumerate(swarm_docs)
+            ]
+            
+            # 6. Rerank
+            logger.info(f"Reranking {len(passages)} swarm-retrieved documents...")
+            rerank_request = RerankRequest(query=standalone_query, passages=passages)
+            reranked_results = self.reranker.rerank(rerank_request)
+            
+            top_score = reranked_results[0]['score'] if reranked_results else 0
+            logger.info(f"Reranking complete. Top score: {top_score:.3f}")
+
+            # 7. Filter 
+            threshold = 0.1
+            if self.domain == "islamic":
+                threshold = 0.05 
+            elif self.domain == "medical":
+                threshold = 0.15
+            else:
+                threshold = 0.10
+                
+            logger.info(f"Using threshold={threshold} for {self.domain} domain")
+            final_docs = []
+            worker_contributions = {}
+            
+            for result in reranked_results:
+                if result['score'] > threshold:
+                    # Re-create the Document object from reranked data
+                    doc = Document(
+                        page_content=result['text'],
+                        metadata=result.get('meta', {})
+                    )
+                    final_docs.append(doc)
+                    
+                    # Track worker contributions in final answer
+                    worker = result.get('meta', {}).get('swarm_worker', 'unknown')
+                    worker_contributions[worker] = \
+                        worker_contributions.get(worker, 0) + 1
+            
+            logger.info(f"Filtered to {len(final_docs)} documents above threshold {threshold}.")
+            logger.info(f"Final doc contributions: {worker_contributions}")
+            
+            self.metrics_tracker.log_worker_contribution(worker_contributions)
+            # 8. Respond
+            if not final_docs:
+                logger.warning("No documents passed the reranker threshold. Returning 'I don't know.'")
+                return "I do not know the answer to that as my document search found no relevant information."
+            
+            # Call the QA chain with the *reranked, filtered* docs
+            response = self.qa_chain.invoke({
+                "context": final_docs,
+                "chat_history": chat_history,
+                "input": query,
+                "domain": self.domain
+            })
+            
+            logger.info("🐝 Swarm RAG pipeline complete. Returning answer.")
+            return response
+
+        except Exception as e:
+            logger.error(f"Error in Swarm RAG pipeline: {e}", exc_info=True)
+            return "An error occurred while processing your request."
+        
+    def _initialize_agent(self):
+        """Build the ReAct agent"""
+        """A helper function to build the agent components."""
+
+        logger.info(f"Initializing agent for domain: '{self.domain}'")
+        self.context_retriever = ContextRetriever(self.retriever)
+        
+        # Store chat_history as instance variable so tools can access it
+        self._current_chat_history = []
+        
+        # We need a RAG chain for the tool
+        # history_aware_retriever = create_history_aware_retriever(self.llm, self.retriever, self.contextualize_q_prompt)
+        # question_answer_chain = create_stuff_documents_chain(self.llm, self.qa_prompt)
+        # rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)
+        
+        def rag_tool_wrapper(query: str) -> str:
+            """Wrapper to pass chat history to RAG pipeline."""
+            return self._run_rag_with_reranking(query, self._current_chat_history)
+        
+        self.tools = [
+            Tool(
+                name="RAG",
+                func=rag_tool_wrapper,
+                description=(f"Use this tool FIRST to search and answer questions about the {self.domain} domain using internal vector database.")
+            )
+            
+        ]
+        
+        # --- DOMAIN-SPECIFIC TOOLS ---
+        if self.domain == "insurance":
+            # Add a specific tool for searching Etiqa's website
+            etiqa_search_tool = TavilySearchResults(max_results=3)
+            etiqa_search_tool.description = "Use this tool to search the Etiqa Takaful website for products NOT in the RAG context (e.g., medical, travel)."
+            # This is a bit of a "hack" to force Tavily to search a specific site.
+            # We modify the function it calls.
+            original_etiqa_func = etiqa_search_tool.invoke
+            def etiqa_site_search(query):
+                return original_etiqa_func(f"site:etiqa.com.my {query}")
+            
+            self.tools.append(Tool(
+                name="EtiqaWebSearch",
+                func=etiqa_site_search,
+                description=etiqa_search_tool.description
+            ))
+            
+            # Add a general web search tool
+            self.tools.append(Tool(
+                name="GeneralWebSearch",
+                func=TavilySearchResults(max_results=2).invoke,
+                description="Use this tool as a fallback for general, non-Etiqa questions (e.g., 'What is takaful?')."
+            ))
+        elif self.domain == "islamic":
+            # Trusted Islamic sources for Malaysia
+            islamic_search = TavilySearchResults(max_results=3)
+            
+            def islamic_trusted_search(query):
+                # Search only trusted Malaysian Islamic authorities
+                sites = "site:muftiwp.gov.my OR site:zulkiflialbakri.com"
+                return islamic_search.invoke(f"{sites} {query}")
+            
+            self.tools.append(Tool(
+            name="TrustedIslamicSearch",
+            func=islamic_trusted_search,
+            description=(
+                "Use this tool if RAG has incomplete or no answer. "
+                "Searches ONLY trusted Malaysian Islamic sources: "
+                "Pejabat Mufti Wilayah Persekutuan (muftiwp.gov.my) and "
+                "Dr Zulkifli Mohamad Al Bakri (zulkiflialbakri.com/category/soal-jawab-agama/). "
+                "These follow Shafi'i madhab which is official in Malaysia."
+            )
+        ))
+        
+            # General fallback (last resort)
+            self.tools.append(Tool(
+                name="GeneralWebSearch",
+                func=TavilySearchResults(max_results=2).invoke,
+                description="Last resort: Use only for general Islamic terms or definitions not found in RAG or trusted sources."
+        ))
+        else:
+            # Medical and Islamic domains only get the general web search fallback
+            self.tools.append(Tool(
+                name="GeneralWebSearch",
+                func=TavilySearchResults(max_results=2).invoke,
+                description="Use this tool as a fallback if the RAG tool finds no relevant information or if the query is about a general topic."
+            ))
+        
+        agent = create_react_agent(llm=self.llm, tools=self.tools, prompt=self.react_docstore_prompt)
+        
+        self.agent_executor = AgentExecutor.from_agent_and_tools(
+            agent=agent,
+            tools=self.tools,
+            handle_parsing_errors=True,
+            verbose=True,
+            return_intermediate_steps=True,
+            max_iterations=5
+        )
+        logger.info(f"✅ Agent Executor(ReAct Agent) created successfully for '{self.domain}'.")
+    
+        
+    def answer(self, query, chat_history=None):
+        """
+        Process a query using the agent and returns a clean dictionary.
+        
+        Args:
+            query (str): User's question
+            chat_history (list): List of previous messages (AIMessage, HumanMessage)
+            
+        Returns:
+            dict: Contains 'answer', 'context', 'validation', 'source', 'thoughts'
+        """
+        if chat_history is None:
+            chat_history = []
+        self._current_chat_history = chat_history
+        if not self.agent_executor:
+            return {"answer": "Error: Agent not initialized.", "context": "", "validation": (False, "Init failed"), "source": "Error"}
+        # START TIMING
+        start_time = self.metrics_tracker.start_query()
+        print(f"\n📝 AGENTIC_QA PROCESSING QUERY: '{query}'")
+        
+        response = self.agent_executor.invoke({
+            "input": query,
+            "chat_history": chat_history,
+            "domain": self.domain, # Pass domain to agent
+            "metadata": {
+                "domain": self.domain
+            }
+        })
+        thoughts= ""
+        
+        final_answer = response.get("output", "Could not generate an answer")
+        
+        tool_used = None
+        if "intermediate_steps" in response:
+            thought_log= []
+            for step in response["intermediate_steps"]:
+                # --- FIX: Unpack the (Action, Observation) tuple first ---
+                action, observation = step
+                
+                if isinstance(action, AgentAction) and action.tool:
+                    tool_used = action.tool #Capture the last tool used
+                
+                # Append Thought, Action, Action Input & Observation 
+                thought_log.append(action.log)
+                thought_log.append(f"\nObservation: {str(observation)}\n---") 
+            
+            thoughts = "\n".join(thought_log)     
+
+        # Assign source based on the LAST tool used
+        if tool_used == "RAG":
+            source = "Etiqa Takaful Database" if self.domain == "insurance" else "Domain Database (RAG)"
+        elif tool_used == "EtiqaWebSearch":
+            source = "Etiqa Website Search"
+        elif tool_used == "TrustedIslamicSearch":
+            source = "Mufti WP & Dr Zul Search"
+        elif tool_used == "GeneralWebSearch":
+            source = "General Web Search"
+        else:
+            source = "Agent Logic"
+
+        logger.info(f"Tool used: {tool_used}, Source determined: {source}")
+        
+        # Retrieve context only if the RAG tool was used
+        # This call is inefficient (it runs a *second* retrieval), but it
+        # respects your architecture and works for logging.
+        context = "No RAG context retrieved."
+        if source.endswith("(RAG)") or source.startswith("Etiqa Takaful Database"):
+            if self.context_retriever:
+                context = self.context_retriever.retrieve(query)
+            else:
+                context = "RAG tool was used, but ContextRetriever not initialized."
+        elif "Web" in source:
+            context = "Web search results were used. See 'Observation' in thoughts log."
+        
+        validation = self.answer_validator.validate(query, final_answer, source=source)
+        # END TIMING
+        response_time = self.metrics_tracker.end_query(start_time)
+        
+        complexity_info = getattr(self, '_last_complexity_analysis', None)
+    
+        # LOG METRICS
+        self.metrics_tracker.log_query(
+            query=query,
+            domain=self.domain,
+            source=source,
+            complexity=complexity_info,
+            validation=validation,
+            response_time=response_time,
+            answer_preview=final_answer
+        )
+        return {"answer": final_answer, "context": context, "validation": validation, "source": source, "thoughts": thoughts,"response_time": response_time,
+        "complexity": complexity_info}
+
+class AnswerValidatorAgent:
+    def __init__(self, llm, domain="general"):
+        self.llm = llm
+        self.domain = domain
+        self.general_prompt = ChatPromptTemplate.from_messages([
+            ("system", (
+                "You are an answer validator. Check if the generated answer is factually correct "
+                "and relevant to the query. Return 'Valid' if the answer is correct and relevant, "
+                "or 'Invalid: [reason]' if not, where [reason] is a brief explanation of the issue."
+            )),
+            ("human", "Query: {query}\nAnswer: {answer}")
+        ])
+        self.medical_prompt = ChatPromptTemplate.from_messages([
+            ("system", (
+                "You are an answer validator. Check if the generated answer is factually correct, "
+                "relevant to the query, and consistent with known medical knowledge. "
+                "Return 'Valid' if the answer is correct and relevant, or 'Invalid: [reason]' if not, "
+                "where [reason] is a brief explanation of the issue. "
+                "**Pay close attention to contradictions.** If an answer gives advice and then "
+                "contradicts it (e.g., 'switch immediately' and then 'always consult your doctor first'), "
+                "it is **Invalid** because it is unsafe and confusing."
+            )),
+            ("human", "Query: {query}\nAnswer: {answer}")
+        ])
+        self.islamic_prompt = ChatPromptTemplate.from_messages([
+            ("system", (
+                "You are an answer validator for Islamic Fiqh or anything related to Islam. Check if the answer correctly addresses "
+                "the query based on the provided sources. The answer should be neutral and present "
+                "the required perspectives (e.g., Shafi'i and Maliki) if available. "
+                "Return 'Valid' if the answer is correct and relevant, or 'Invalid: [reason]' if not."
+            )),
+            ("human", "Query: {query}\nAnswer: {answer}")
+        ])
+
+    def validate(self, query, answer, source="RAG"):
+        if self.domain == "insurance":
+            logger.info("Skipping validation for insurance domain.")
+            return True, "Validation skipped for insurance domain."
+        
+        try:
+            # --- 11. IMPROVED VALIDATOR LOGIC ---
+            # Choose the right prompt based on domain and source
+            prompt = self.general_prompt # Default
+            if source == "RAG" or "Database" in source:
+                if self.domain == "medical":
+                    prompt = self.medical_prompt
+                elif self.domain == "islamic":
+                    prompt = self.islamic_prompt
+            
+            response = self.llm.invoke(prompt.format(query=query, answer=answer))
+            validation = response.content.strip()
+            logger.info(f"AnswerValidator result for query '{query}': {validation}")
+
+            if validation.lower().startswith("valid"):
+                return True, "Answer is valid and relevant."
+            elif validation.lower().startswith("invalid"):
+                reason = validation.split(":", 1)[1].strip() if ":" in validation else "No reason provided."
+                return False, reason
+            else:
+                return False, "Validation response format unexpected."
+        except Exception as e:
+            logger.error(f"AnswerValidator error: {str(e)}")
+            return False, "Validation failed due to error."

src/medical_swarm.py

@@ -0,0 +1,149 @@
+import logging
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+import traceback
+import os
+
+#1. SETUP
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Load env
+load_dotenv()
+google_api_key=os.getenv("GOOGLE_API_KEY")
+if not google_api_key:
+    raise ValueError("GOOGLE_API_KEY not found in environment variable.Make sure it is in .env file")
+
+# Agent Definition
+NO_SUGGESTIONS_INSTRUCTION= (
+    "This is a finalized medical report.Do not provide suggestions or improvements."
+    "Focus strictly on your assigned task based on the provided data"
+)
+class MedicalAgent:
+    def __init__(self, llm, name:str, role_prompt: str):
+        self.llm = llm
+        self.name = name
+        self.role_prompt= role_prompt
+    
+    def run(self, input_data:str):
+        
+        try:
+            logger.info(f"Agent '{self.name}' is processing")
+            full_prompt=f"{NO_SUGGESTIONS_INSTRUCTION}\n\n{self.role_prompt}\n\n{input_data}"
+            response=self.llm.invoke(full_prompt)
+            logger.info(f"Agent {self.name} finished")
+            return response.content
+        except Exception as e:
+            logger.error(f"Agent {self.name} error: {str(e)}")
+            traceback.print_exc()
+            return f"Error in agent {self.name}: {str(e)}"
+
+# Initialize SWARM
+llm=ChatGoogleGenerativeAI(model="gemini-2.5-pro",temperature=0.1,google_api_key=google_api_key)
+
+#Define specific roles for each agent in the team
+medical_data_extractor = MedicalAgent(
+    llm, "Medical Data Extractor",
+    "You are a specialized medical data extraction expert. Your role is to extract relevant medical information, focusing on key clinical indicators, test results, vital signs, and patient history from the provided text."
+    )
+diagnostic_specialist = MedicalAgent(
+    llm, "Diagnostic Specialist",
+    "You are a senior diagnostic physician. Your role is to analyze the provided symptoms, lab results, and clinical findings to develop a diagnostic assessment based solely on the data."
+    )
+treatment_planner = MedicalAgent(
+    llm, "Treatment Planner",
+    "You are an experienced clinical treatment specialist. Your role is to outline a prescribed treatment plan (pharmacological and non-pharmacological interventions) based on the provided diagnosis and data."
+    )
+specialist_consultant = MedicalAgent(
+    llm, "Specialist Consultant",
+    "You are a medical specialist consultant. Your role is to provide deep insights on the existing diagnosis and treatment plan, highlighting any potential complications or considerations based on the record."
+    )
+patient_care_coordinator = MedicalAgent(
+    llm, "Patient Care Coordinator (Orchestrator)",
+    "You are a patient care coordinator specializing in comprehensive healthcare management. Your primary role is to manage a team of specialist agents and synthesize their findings."
+    )
+
+# ORCHESTRATOR LOGIC
+def run_medical_swarm(document_text: str, initial_query: str,chat_history: list = None):
+    """
+    Orchestrates a swarm of medical agents to analyze document.
+    
+    Args:
+        document_text: The full text of medical record
+        initial_query: The initial question or goal of analysis
+    
+    Returns:
+        A string containing final, synthesized response
+    """
+    logger.info("--- MEDICAL SWARM INITIATED ---")
+    
+    # If there's a history, use it as the starting point. Otherwise, start fresh.
+    workspace = [f"Initial Patient Document:\n{document_text}", f"Initial Goal: '{initial_query}'"]
+    
+    # The Patient Care Coordinator is our orchestrator/manager
+    orchestrator= patient_care_coordinator
+    
+    # Limit the number of collab rounds to prevent infinite loops
+    for i in range(5):
+        logger.info(f"\n-- Swarm Iteration {i+1} --")
+        current_state = "\n\n".join(workspace)
+        
+        # The orchestrator reviews the current state and decide the next action.
+        orchestrator_prompt= f"""
+        You are the Patient Care Coordinator managing a team of specialist AI agents to analyze a medical case.
+        Review the current Case File below and decide the single next best action.
+
+        Your available specialists are:
+        - 'medical_data_extractor': Best for the first step to get raw data from the initial document.
+        - 'diagnostic_specialist': Best for forming a diagnosis after key data has been extracted.
+        - 'treatment_planner': Best for creating a plan after a clear diagnosis is available.
+        - 'specialist_consultant': Best for getting deeper insight on an existing diagnosis or plan.
+
+        Case File (Summary of work so far):
+        ---
+        {current_state}
+        ---
+
+        Based on the file, which specialist should be called next? Or, if you have a clear diagnosis, treatment plan, and specialist insight, is it time to write the final summary for the patient?
+
+        Respond with ONLY one of the following commands:
+        - "CALL: medical_data_extractor"
+        - "CALL: diagnostic_specialist"
+        - "CALL: treatment_planner"
+        - "CALL: specialist_consultant"
+        - "FINISH"
+        """
+        command=orchestrator.run(orchestrator_prompt).strip().upper()       
+        logger.info(f"Orchestrator Command: {command}")
+        
+        if command == "CALL: MEDICAL_DATA_EXTRACTOR":
+            report= medical_data_extractor.run(f"Original Document:\n{document_text}")
+            workspace.append(f"--- Extractor's Report ---\n{report}")
+            
+        elif command == "CALL: DIAGNOSTIC_SPECIALIST":
+            # Other agents get the whole workspace for context
+            report = diagnostic_specialist.run(f"Full Case File for Diagnosis:\n{current_state}")
+            workspace.append(f"--- Diagnostician's Report ---\n{report}")
+            
+        elif command == "CALL: TREATMENT_PLANNER":
+            report = treatment_planner.run(f"Full Case File for Treatment Plan:\n{current_state}")
+            workspace.append(f"--- Treatment Planner's Report ---\n{report}")
+            
+        elif command == "CALL: SPECIALIST_CONSULTANT":
+            report = specialist_consultant.run(f"Full Case File for Specialist Consultation:\n{current_state}")
+            workspace.append(f"--- Specialist Consultant's Report ---\n{report}")
+            
+        elif command == "FINISH":
+            logger.info("Orchestrator has decided the work is complete. Generating final summary.")
+            final_summary_prompt = f"You are the Patient Care Coordinator. Based on the complete case file below, write a comprehensive, patient-facing summary that coordinates all the findings.\n\nFull Case File:\n{current_state}"
+            final_answer = orchestrator.run(final_summary_prompt)
+            return final_answer
+        else:
+            logger.warning(f"Orchestrator gave an unknown command: '{command}'. Ending swarm.")
+            break
+        
+    # Fallback if the loop finishes without a "FINISH" command
+    logger.warning("Swarm reached max iterations. Finalizing with current data.")
+    final_fallback_prompt = f"You are the Patient Care Coordinator. The analysis time has expired. Summarize the findings from the case file below into a cohesive patient-facing report.\n\nFull Case File:\n{current_state}"
+    final_answer = orchestrator.run(final_fallback_prompt)
+    return final_answer        

src/metrics_tracker.py

@@ -0,0 +1,206 @@
+import time
+from datetime import datetime
+from collections import defaultdict
+import json
+import os
+
+class MetricsTracker:
+    """
+    Tracks system performance metrics across queries.
+    """
+    
+    def __init__(self, save_path="metrics_data.json"):
+        self.save_path = save_path
+        self.metrics = {
+            "total_queries": 0,
+            "rag_success": 0,
+            "web_search_fallback": 0,
+            "trusted_search_used": 0,
+            "general_search_used": 0,
+            "complexity_distribution": {
+                "simple": 0,
+                "moderate": 0,
+                "complex": 0
+            },
+            "domain_usage": {
+                "medical": 0,
+                "islamic": 0,
+                "insurance": 0
+            },
+            "response_times": [],
+            "worker_contributions": {
+                "dense_semantic": 0,
+                "bm25_keyword": 0
+            },
+            "validation_stats": {
+                "valid": 0,
+                "invalid": 0,
+                "skipped": 0
+            },
+            "query_history": []  # Store recent queries for analysis
+        }
+        
+        # Load existing metrics if available
+        self.load_metrics()
+    
+    def start_query(self):
+        """Start timing a query."""
+        return time.time()
+    
+    def end_query(self, start_time):
+        """Calculate and store query response time."""
+        response_time = time.time() - start_time
+        self.metrics["response_times"].append(response_time)
+        return response_time
+    
+    def log_query(self, query, domain, source, complexity=None, 
+                  validation=None, response_time=None, answer_preview=None):
+        """
+        Log a complete query with all its metadata.
+        
+        Args:
+            query (str): User's query
+            domain (str): Domain (medical, islamic, insurance)
+            source (str): Where answer came from (RAG, WebSearch, etc.)
+            complexity (dict): Complexity analysis result
+            validation (tuple): (is_valid, reason)
+            response_time (float): Time taken in seconds
+            answer_preview (str): First 100 chars of answer
+        """
+        self.metrics["total_queries"] += 1
+        
+        # Track domain usage
+        if domain in self.metrics["domain_usage"]:
+            self.metrics["domain_usage"][domain] += 1
+        
+        # Track source usage
+        if "RAG" in source or "Database" in source:
+            self.metrics["rag_success"] += 1
+        elif "Trusted" in source:
+            self.metrics["trusted_search_used"] += 1
+            self.metrics["web_search_fallback"] += 1
+        elif "Etiqa" in source:
+            self.metrics["web_search_fallback"] += 1
+        elif "Web" in source or "Search" in source:
+            self.metrics["general_search_used"] += 1
+            self.metrics["web_search_fallback"] += 1
+        
+        # Track complexity distribution
+        if complexity and "complexity" in complexity:
+            comp_level = complexity["complexity"]
+            if comp_level in self.metrics["complexity_distribution"]:
+                self.metrics["complexity_distribution"][comp_level] += 1
+        
+        # Track validation
+        if validation:
+            is_valid, reason = validation
+            if "skip" in reason.lower():
+                self.metrics["validation_stats"]["skipped"] += 1
+            elif is_valid:
+                self.metrics["validation_stats"]["valid"] += 1
+            else:
+                self.metrics["validation_stats"]["invalid"] += 1
+        
+        # Store query history (last 50 queries)
+        query_record = {
+            "timestamp": datetime.now().isoformat(),
+            "query": query[:100],  # Truncate long queries
+            "domain": domain,
+            "source": source,
+            "complexity": complexity.get("complexity") if complexity else None,
+            "k_used": complexity.get("k") if complexity else None,
+            "response_time": round(response_time, 2) if response_time else None,
+            "validated": is_valid if validation else None,
+            "answer_preview": answer_preview[:100] if answer_preview else None
+        }
+        
+        self.metrics["query_history"].append(query_record)
+        
+        # Keep only last 50 queries
+        if len(self.metrics["query_history"]) > 50:
+            self.metrics["query_history"] = self.metrics["query_history"][-50:]
+        
+        # Auto-save after each query
+        self.save_metrics()
+    
+    def log_worker_contribution(self, worker_stats):
+        """
+        Log which swarm workers contributed to the final answer.
+        
+        Args:
+            worker_stats (dict): e.g., {"dense_semantic": 5, "bm25_keyword": 3}
+        """
+        for worker, count in worker_stats.items():
+            if worker in self.metrics["worker_contributions"]:
+                self.metrics["worker_contributions"][worker] += count
+    
+    def get_stats(self):
+        """Get current statistics."""
+        total = self.metrics["total_queries"]
+        
+        if total == 0:
+            return {
+                "total_queries": 0,
+                "rag_success_rate": 0,
+                "web_search_rate": 0,
+                "avg_response_time": 0,
+                "complexity_distribution": self.metrics["complexity_distribution"],
+                "domain_usage": self.metrics["domain_usage"]
+            }
+        
+        # Calculate averages and percentages
+        avg_response_time = (
+            sum(self.metrics["response_times"]) / len(self.metrics["response_times"])
+            if self.metrics["response_times"] else 0
+        )
+        
+        stats = {
+            "total_queries": total,
+            "rag_success_rate": round((self.metrics["rag_success"] / total) * 100, 1),
+            "web_search_rate": round((self.metrics["web_search_fallback"] / total) * 100, 1),
+            "trusted_search_rate": round((self.metrics["trusted_search_used"] / total) * 100, 1),
+            "general_search_rate": round((self.metrics["general_search_used"] / total) * 100, 1),
+            "avg_response_time": round(avg_response_time, 2),
+            "median_response_time": self._get_median(self.metrics["response_times"]),
+            "complexity_distribution": self.metrics["complexity_distribution"],
+            "domain_usage": self.metrics["domain_usage"],
+            "worker_contributions": self.metrics["worker_contributions"],
+            "validation_stats": self.metrics["validation_stats"],
+            "recent_queries": self.metrics["query_history"][-10:]  # Last 10 queries
+        }
+        
+        return stats
+    
+    def _get_median(self, values):
+        """Calculate median of a list."""
+        if not values:
+            return 0
+        sorted_values = sorted(values)
+        n = len(sorted_values)
+        mid = n // 2
+        if n % 2 == 0:
+            return round((sorted_values[mid-1] + sorted_values[mid]) / 2, 2)
+        return round(sorted_values[mid], 2)
+    
+    def save_metrics(self):
+        """Save metrics to JSON file."""
+        try:
+            with open(self.save_path, 'w') as f:
+                json.dump(self.metrics, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Could not save metrics: {e}")
+    
+    def load_metrics(self):
+        """Load metrics from JSON file if it exists."""
+        if os.path.exists(self.save_path):
+            try:
+                with open(self.save_path, 'r') as f:
+                    self.metrics = json.load(f)
+                print(f"✅ Loaded existing metrics from {self.save_path}")
+            except Exception as e:
+                print(f"Warning: Could not load metrics: {e}")
+    
+    def reset_metrics(self):
+        """Reset all metrics (useful for testing)."""
+        self.__init__(self.save_path)
+        self.save_metrics()

src/utils.py

@@ -0,0 +1,96 @@
+import logging
+import json
+import re
+from src.doc_qa import AgenticQA
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+logger = logging.getLogger(__name__)
+
+def load_rag_system(collection_name,domain):
+    """
+    Loads an existing RAG system by connecting to the persistent vector store.
+    This is fast and does not re-process any documents.
+    """
+    logger.info(f"Loading RAG system for collection: '{collection_name}'  (Domain: {domain})...")
+    try:
+        agent = AgenticQA(
+            config={
+                "retriever": {
+                    "collection_name": collection_name,
+                    "persist_directory": "chroma_db"
+                },
+                "domain": domain
+            }
+        )
+        # Check if the agent was actually created
+        if not agent.agent_executor:
+            raise Exception("Agent Executor was not created. Check logs for errors.")
+
+        logger.info(f"✅ System for '{collection_name}' loaded successfully.")
+        return agent
+    except Exception as e:
+        logger.error(f"❌ Failed to load RAG system for '{collection_name}': {e}")
+        logger.warning("Did you run the ingest.py script first?")
+        return None
+
+def markdown_bold_to_html(text: str):
+    """Converts markdown bold syntax to HTML <strong> tags."""
+    return re.sub(r"\*\*(.*?)\*\*", r"<strong>\1</strong>", text)
+
+def standardize_query(query):
+    if not query:
+        return None
+    return query.strip().lower()
+
+def get_standalone_question(input_question, chat_history,llm):
+    """Uses LLM to create a standalone question from the chat history."""
+    if not chat_history:
+        return input_question
+    
+    contextualize_q_prompt = ChatPromptTemplate.from_messages([
+        ("system", "Given a chat history and the latest user question which might reference context in the chat history, "
+        "formulate a standalone question which can be understood without the chat history. "
+        "IMPORTANT: DO NOT PROVIDE ANY ANSWERS. ONLY REPHRASE THE QUESTION IF NEEDED. "
+        "If the question is already clear and standalone, return it exactly as is. "
+        "Output ONLY the reformulated question, nothing else."),
+        MessagesPlaceholder("chat_history"),
+        ("human", "{input}"),
+    ])
+    history_aware_retriever_chain = contextualize_q_prompt | llm
+    
+    response = history_aware_retriever_chain.invoke(
+        {"chat_history": chat_history, "input": input_question}
+    )
+    return response.content
+
+def parse_agent_response(response_dict):
+    """A robust helper to parse the dictionary from an AgenticQA agent."""
+    answer = markdown_bold_to_html(response_dict.get('answer', 'Error: No answer found.'))
+    thoughts = response_dict.get('thoughts', 'No thought process available.')
+    validation = response_dict.get('validation', (False, 'Validation failed.'))
+    source = response_dict.get('source', 'Unknown')
+    
+    if validation and validation[1] == "Validation skipped for insurance domain.":
+        validation = (True, "Factual Answer")
+        
+    return answer, thoughts,validation, source
+    
+def extract_json_from_string(text: str) -> dict:
+    """
+    Finds and parses the first valid JSON object within a string.
+    Returns a dictionary, or an empty dict if no JSON is found.
+    """
+    # This regex finds the first occurrence of a string starting with { and ending with }
+    json_match = re.search(r'\{.*\}', text, re.DOTALL)
+    
+    if json_match:
+        json_string = json_match.group(0)
+        try:
+            return json.loads(json_string)
+        except json.JSONDecodeError:
+            # The extracted string is not valid JSON
+            return {"error": "Failed to parse extracted JSON", "raw_text": json_string}
+    else:
+        # No JSON object found in the string
+        return {"error": "No JSON object found in the string", "raw_text": text}