Delete document-based-assistant

document-based-assistant/app.py

@@ -1,76 +0,0 @@
-from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool
-from tools import DocumentRetrievalTool, DocumentSummarizationTool, CodeExecutionTool
-from retriever import load_document, chunk_text, embed_text, vector_store
-import torch
-from transformers import pipeline
-import gradio as gr
-from huggingface_hub import InferenceClient
-import os
-
-docs = load_document("docs")     
-chunks = []
-for doc in docs:
-    chunks.extend(chunk_text(doc["content"]))                    
-embeddings = embed_text(chunks)                       
-
-ids = [f"chunk_{i}" for i in range(len(chunks))]
-metadatas = [{"source": "unknown", "chunk_index": i} for i in range(len(chunks))]
-
-chroma_collection = vector_store(
-    collection=None,
-    ids=ids,
-    documents=chunks,
-    metadatas=metadatas,
-    embeddings=embeddings
-)
-
-doc_tool = DocumentRetrievalTool(
-    collection=chroma_collection
-)
-
-summarization_pipeline = pipeline(
-    task="summarization",
-    model="google/pegasus-xsum",
-    dtype=torch.float16,
-    device=-1
-)
-
-summarize_tool = DocumentSummarizationTool(
-    summarization_pipeline=summarization_pipeline
-)
-
-model = InferenceClientModel(client=InferenceClient(model="google/flan-t5-large")) # naveensharma16/document-based-assistant
-print("Loaded model:", model)
-
-agent = CodeAgent(
-    tools=[doc_tool, summarize_tool, DuckDuckGoSearchTool(), CodeExecutionTool()],
-    model=model,
-    stream_outputs=False # True
-)
-
-def predict(query: str):
-    """GAIA entrypoint"""
-    return agent.run(query)
-
-iface = gr.Interface(
-    fn=predict,
-    inputs="text",
-    outputs="text",
-    title="Document QA Agent"
-)
-
-# def agent_interface(query):
-#     return agent.run(query)
-
-# iface = gr.Interface(
-#     fn=agent_interface,
-#     inputs="text",
-#     outputs="text",
-#     title="Document QA Agent"
-# )
-
-if __name__ == "__main__":
-    if os.getenv("RUN_GAIA", "true") == "true":
-        run_gaia_test("naveensharma16")
-    iface.launch(server_name="0.0.0.0", server_port=7860)
-

document-based-assistant/docs/doc1.txt

@@ -1,20 +0,0 @@
-Agent & Tool-Based Automation Workflow – Using Retrieval & Generation
-
-In modern automation systems, agents and tools work in tandem to bridge the gap between user intent and actionable workflows. An agent is the 
-orchestrator—it interprets natural language requests, selects the appropriate tools, and supervises the execution of subtasks. Tools are the 
-specialised components the agent invokes: for retrieval of knowledge, execution of code, external API calls, or summarisation of results. 
-By separating these concerns, you build a flexible system: the agent handles reasoning and decision-making, while tools execute concrete operations.
-
-Retrieval plays a pivotal role in this architecture. Before generation, the system identifies relevant context or data—perhaps past automation scripts, 
-documentation, or process logs—using a retriever tool. That context is fed into the generation stage, where the agent or model crafts a response or 
-action plan grounded in the retrieved evidence. This Retrieval-Augmented Generation (RAG) pattern ensures that the system doesn’t hallucinate its 
-way to an answer but bases its output on real, indexed information.
-
-Tool invocation adds another dimension of operational power. Once the agent decides “I need this tool”, it passes structured inputs to the tool, 
-receives a result, and continues its reasoning with that result. For example: user says “Create a script that uploads the latest financial report.” 
-The agent retrieves the report template, invokes a code-generation tool, reviews the generated script via another tool, and then executes or delivers 
-the final output. Each step is visible, modular, and auditable.
-
-Finally, good workflows enforce guardrails, feedback loops and evaluation. The agent should know when to escalate to a human, how to log tool usage
-(for observability), and how to evaluate whether the output meets criteria (accuracy, relevance, correctness). Embedding these practices from the 
-start allows the system to evolve—improving over time, scaling across domains, and adapting to new use-cases without breaking.

document-based-assistant/docs/doc2.txt

@@ -1,18 +0,0 @@
-Best Practices for Automated Documentation
-
-In today’s fast-paced digital landscape, documentation is no longer a static “write once and forget” artifact—it must evolve dynamically and continuously 
-alongside the systems it describes. Automated documentation systems help organisations maintain accuracy, consistency and accessibility, especially when 
-handling high volumes of documents or frequent process changes. By establishing clear documentation standards, integrating automation tools into existing 
-data stacks, leveraging metadata, and implementing version control, automated documentation becomes a powerful enabler of transparency and efficiency.
-
-One of the key steps in successful documentation automation is selecting the right tools and aligning them to your organisational environment. For 
-instance, you should choose software that seamlessly integrates with your database, document management system or ERP, supports the formats you use 
-(e.g., PDF, HTML, Markdown) and offers robust versioning and audit trails. Further, good practice requires ongoing review and update cycles—automated 
-doesn’t mean “never verify”. Regular audits, monitoring of documentation churn and verifying that the generated material reflects the live system 
-are critical.
-
-Automated documentation also benefits from thoughtful metadata design. By capturing context such as authorship, timestamps, document versions, relevant 
-stakeholders, and workflows, your system supports better searchability, traceability and governance. Automation that’s aware of metadata reduces 
-duplication and makes retrieval faster and more reliable. Finally, security and governance cannot be an after-thought. Handling documentation—especially 
-in regulated domains or with sensitive information—requires access controls, encryption, audit logs and compliance with data-retention policies. 
-Treatment of documentation as a critical asset, with clear ownership and management processes, ensures your automated approach remains robust.

document-based-assistant/docs/doc3.txt

@@ -1,20 +0,0 @@
-AI Agent Workflows – An Introduction & Best Practices
-
-Modern AI agents are more than chatbots—they are systems capable of autonomously performing tasks, connecting to tools, retrieving knowledge, and making
-decisions. At their core, an agent takes input (a user request), reasons about what to do (which tools to call or which data to fetch), executes 
-operations, and returns output. This workflow involves: interpreting intent → selecting action → retrieving context/data → executing tools/commands
-→ generating a response or action. By mapping out this sequence clearly, you build agents that are predictable and effective.
-
-One of the most important steps in agent workflows is retrieval of context. When an agent is asked a question or given a task, it often needs data 
-beyond its training—such as documents, APIs, logs or databases. A retrieval component finds relevant pieces of evidence, which are then used by the 
-generation or tool-execution stage. Without such context, the agent risks hallucinating or producing irrelevant output.
-
-Equally important is tool invocation and orchestration. Once the agent has retrieved relevant context, it may decide to call a tool—for example, 
-running a script, accessing a database, invoking an API, or performing a calculation. The workflow must clearly define how tools are selected, how 
-inputs are formed, how outputs are handled, and how errors or unexpected results are managed. Modularising tools and defining interfaces make this 
-step robust and maintainable.
-
-Finally, building production-worthy agent workflows demands governance, observability and iterative improvement. Agents should log their decisions 
-(which tool was called, what data was retrieved), monitor performance (latency, accuracy, failures) and allow for human intervention when needed. 
-Best practice also says to start with narrow-scoped tasks (one reliable function) and expand gradually, ensuring each stage works before scaling. 
-With these practices, your agent workflows become both reliable and extendable.

document-based-assistant/docs/doc4.txt

@@ -1,20 +0,0 @@
-AI Agent Workflows – An Introduction & Best Practices
-
-Modern AI agents are more than chatbots—they are systems capable of autonomously performing tasks, connecting to tools, retrieving knowledge, and making
-decisions. At their core, an agent takes input (a user request), reasons about what to do (which tools to call or which data to fetch), executes 
-operations, and returns output. This workflow involves: interpreting intent → selecting action → retrieving context/data → executing tools/commands → 
-generating a response or action. By mapping out this sequence clearly, you build agents that are predictable and effective.
-
-One of the most important steps in agent workflows is retrieval of context. When an agent is asked a question or given a task, it often needs data 
-beyond its training—such as documents, APIs, logs or databases. A retrieval component finds relevant pieces of evidence, which are then used by the 
-generation or tool-execution stage. Without such context, the agent risks hallucinating or producing irrelevant output.
-
-Equally important is tool invocation and orchestration. Once the agent has retrieved relevant context, it may decide to call a tool—for example, 
-running a script, accessing a database, invoking an API, or performing a calculation. The workflow must clearly define how tools are selected, how 
-inputs are formed, how outputs are handled, and how errors or unexpected results are managed. Modularising tools and defining interfaces make this 
-step robust and maintainable.
-
-Finally, building production-worthy agent workflows demands governance, observability and iterative improvement. Agents should log their decisions 
-(which tool was called, what data was retrieved), monitor performance (latency, accuracy, failures) and allow for human intervention when needed. 
-Best practice also says to start with narrow-scoped tasks (one reliable function) and expand gradually, ensuring each stage works before scaling. 
-With these practices, your agent workflows become both reliable and extendable.

document-based-assistant/docs/docs5.txt

@@ -1,22 +0,0 @@
-RAG Evaluation – Best Practices for Retrieval-Augmented Generation Systems
-
-Evaluation is a critical step when building a Retrieval-Augmented Generation (RAG) system. A successful RAG system must not only retrieve relevant 
-documents but also generate accurate, grounded responses based on that context. Without proper evaluation, errors in retrieval or generation can slip 
-into production, causing misleading answers or user frustration.
-
-First, treat the retrieval and generation components separately. For retrieval, measure how well the system finds useful documents: metrics like 
-precision@k (how many of the top k retrieved are actually relevant) and recall@k (how many relevant documents were retrieved) help you locate 
-weaknesses in your vector store or embedding model. For generation, assess whether the answer is correct, relevant, coherent and faithful to the 
-retrieved context. If your agent produces fluent text but it’s not grounded in the retrieved material, you’ll face trust issues.
-
-Second, build a structured test set early. Select a variety of realistic questions that reflect how users will use the system. For each, define 
-expected outcomes or “gold” answers when possible. By using the same test set across iterations, you can compare performance when you change chunking 
-methods, vector stores, or prompts. This consistency ensures that improvements are measurable and meaningful.
-
-Third, automate the evaluation process. Setup scripts or pipelines that run the test set, compute metrics, record results, and plot trends. This 
-way you can track regression, monitor when performance drops (for example if the knowledge base changes), and set thresholds for when to alert for 
-human review. Continuous monitoring is especially important as your document base grows or becomes dynamic.
-
-Finally, remember that evaluation is ongoing—once you deploy your agent, user behaviour will evolve, documents will change, and queries will shift. 
-Plan periodic re-evaluation (e.g., monthly or after major updates), refresh test sets, and maintain logs of system decisions. By doing so, you ensure 
-your RAG assistant stays reliable and effective over time.

document-based-assistant/retriever.py

@@ -1,121 +0,0 @@
-import os
-from typing import List, Dict, Any
-from sentence_transformers import SentenceTransformer
-import chromadb
-
-FOLDER_PATH = "/home/nishtha/document-based-assistant/docs"
-
-model = SentenceTransformer("all-MiniLM-L6-v2")
-chroma_client = chromadb.Client() 
-
-def load_document(docs_path: str = FOLDER_PATH) -> List[Dict[str, Any]]:
-    """
-    Load text documents from docs_path.
-    """
-    documents = []
-    for doc in os.listdir(docs_path):
-        filepath = os.path.join(docs_path, doc)
-        with open(filepath, 'r', encoding='utf-8') as file:
-            content = file.read()
-            documents.append({
-                "filename": doc,
-                "content": content
-            })
-    return documents
-
-
-def chunk_text(content: str, max_tokens: int = 250, overlap_tokens: int = 50) -> List[str]:
-    """
-    Clean, preprocess and split a long text into chunks of up to max_tokens,
-    with overlap of overlap_tokens between consecutive chunks to preserve context.
-    """
-    content = content.strip()
-    content = " ".join(content.split())
-    content = content.lower()
-    
-    words = content.split()
-    chunks = []
-    start = 0
-    length = len(words)
-    
-    while start < length:
-        end = min(start + max_tokens, length)
-        chunk = " ".join(words[start:end])
-        chunks.append(chunk)
-        
-        start += (max_tokens - overlap_tokens)
-    
-    return chunks
-
-
-def embed_text(chunks: List[str], batch_size: int = 32) -> List[List[float]]:
-    """
-    Embed text chunks using the pre-loaded SentenceTransformer model.
-    Returns a list of embeddings.
-    """
-    embeddings = model.encode(chunks, batch_size=batch_size, convert_to_tensor=False, show_progress_bar=True)
-    return embeddings
-
-
-def vector_store(collection, ids: list, documents: list, metadatas: list, embeddings: list = None):
-    """
-    Create or get a ChromaDB collection for storing embeddings.
-    """
-    collection = chroma_client.get_or_create_collection(name="document_assistant_collection")
-    collection.add(
-        ids=ids,
-        documents=documents,
-        metadatas=metadatas,
-        embeddings=embeddings,
-        )
-    return collection
-
-
-def retrieve_query(query: str, collection, top_k: int = 5) -> List[Dict[str, Any]]:
-    """
-    Retrieve the top_k most relevant document chunks for the given query from the collection."""
-    clean_q = query.strip().lower()
-    q_emb = model.encode([clean_q], convert_to_tensor=False)[0]
-    results = collection.query(
-        query_embeddings=[q_emb],
-        n_results=top_k,
-        include=["documents", "metadatas", "distances"]
-    )
-    retrieved = []
-    docs_list = results["documents"][0]
-    metas_list = results["metadatas"][0]
-    dists_list = results["distances"][0]
-    for text, meta, dist in zip(docs_list, metas_list, dists_list):
-        retrieved.append({
-            "source": meta.get("source"),
-            "text": text,
-            "score": dist
-        })
-    return retrieved
-  
-if __name__ == "__main__":
-    # Get or create the collection
-    collection = chroma_client.get_or_create_collection(name="document_assistant_collection")
-
-    # Load and prepare documents
-    docs = load_document()
-    ids, chunks, metas = [], [], []
-    for d in docs:
-        for idx, c in enumerate(chunk_text(d["content"], max_tokens=250, overlap_tokens=50)):
-            ids.append(f"{d['filename']}_chunk{idx}")
-            chunks.append(c)
-            metas.append({"source": d["filename"], "chunk_index": idx})
-
-    # Embed chunks and add to vector store
-    embeddings = embed_text(chunks, batch_size=32)
-    coll = vector_store(collection, ids=ids, documents=chunks, metadatas=metas, embeddings=embeddings)
-
-    # Interactive question loop
-    while True:
-        q = input("Your question (or 'exit'): ")
-        if q.lower() in ("exit", "quit"):
-            break
-        results = retrieve_query(q, coll, top_k=5)
-        for r in results:
-            print(f"Source: {r['source']} | Score: {r['score']}\nText: {r['text']}\n---")
-

document-based-assistant/tools.py

@@ -1,109 +0,0 @@
-from smolagents import Tool
-from typing import Dict, Any, List
-from retriever import retrieve_query
-import io
-from contextlib import redirect_stdout
-
-class DocumentRetrievalTool(Tool):
-    """
-    A tool for performing semantic search across a document knowledge base stored in ChromaDB.
-    It accepts a query and retrieves the most relevant document chunks.
-    """
-    name = "document_retrieval"
-    description = (
-        "Use this tool to search for specific, relevant information within the loaded document set. "
-        "Always use this when the user's question relates to the content of the documents."
-    )
-    inputs = {
-        "query": {
-            "type": "string",
-            "description": "The search query, which must be a specific question or topic related to the document's content."
-        }
-    }
-    output_type = "string"
-
-    def __init__(self, collection: Any):
-        self.collection = collection
-        super().__init__()
-
-    def forward(self, query: str) -> str:
-        """
-        Performs a query using the custom retrieval function and returns the results 
-        formatted for the agent.
-        """
-        retrieved_results: List[Dict[str, Any]] = retrieve_query(query, self.collection, top_k=5)
-        context_parts = []
-        for result in retrieved_results:
-            context_parts.append(
-                f"Source ({result['source']}): {result['text']}"
-            )
-        context = "\n---\n".join(context_parts)
-        
-        return (
-            f"Retrieved context from document:\n\n{context}\n\n"
-        )
-    
-class DocumentSummarizationTool(Tool):
-    """
-    A tool that summarizes a given document text using pre-trained summarization model.
-    """
-    name = "document_summarization"
-    description = (
-        "Use this tool to summarize a loaded document set."
-    )
-    inputs = {
-        "document_text": {
-            "type": "string",
-            "description": "The document text to be summarized."
-        }
-    }
-    output_type = "string"
-
-    def __init__(self, summarization_pipeline: Any):
-        self.summarization_pipeline = summarization_pipeline
-        super().__init__()
-
-    def forward(self, document_text: str) -> str:
-        """
-        Performs summarization using the provided summarization pipeline.
-        """
-        summary_output = self.summarization_pipeline(document_text)
-        return summary_output[0]["summary_text"]
-    
-
-class CodeExecutionTool(Tool):
-    """
-    A sandboxed tool for executing Python code (e.g., for calculations, 
-    data manipulation, or simple logic puzzles) that the LLM might struggle with).
-    """
-    name: str = "python_interpreter"
-    description: str = (
-        "A Python interpreter used to run short snippets of code for calculations "
-        "or logic. The input must be valid Python code. The tool captures and "
-        "returns any printed output."
-    )
-    inputs = {
-        "code": {
-            "type": "string",
-            "description": "The Python code to execute. Must be a single code block."
-        }
-    }
-    output_type = "string"
-
-    def forward(self, code: str) -> str:
-        """
-        Executes the given Python code in a restricted environment.
-        """
-        safe_builtins = {'print': print, 'len': len, 'sum': sum, 'min': min, 'max': max, 'range': range, 'str': str, 'int': int, 'float': float}
-        safe_globals = {'__builtins__': safe_builtins}
-        output_buffer = io.StringIO()
-
-        try:
-            with redirect_stdout(output_buffer):
-                exec(code, safe_globals)
-            
-            output = output_buffer.getvalue()
-            return f"Code Output:\n{output.strip()}" if output else "No output. Did you forget print()?"
-        
-        except Exception as e:
-            return f"Code Execution Error: {type(e).__name__}: {str(e)}"