Upload 8 files

app.py

@@ -0,0 +1,64 @@
+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
+
+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("naveensharma16/my-agent-gaia-test")
+model = InferenceClientModel(
+    client=InferenceClient()
+)
+
+agent = CodeAgent(
+    tools=[doc_tool, summarize_tool, DuckDuckGoSearchTool(), CodeExecutionTool()],
+    model=model,
+    stream_outputs=True
+)
+
+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__":
+    iface.launch(server_name="0.0.0.0", server_port=7860)
+

docs/doc1.txt

@@ -0,0 +1,20 @@
+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.

docs/doc2.txt

@@ -0,0 +1,18 @@
+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.

docs/doc3.txt

@@ -0,0 +1,20 @@
+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.

docs/doc4.txt

@@ -0,0 +1,20 @@
+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.

docs/docs5.txt

@@ -0,0 +1,22 @@
+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.

retriever.py

@@ -0,0 +1,121 @@
+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---")
+

tools.py

@@ -0,0 +1,109 @@
+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)}"