घर पर मुफ्त में एजेंट बनाएं: ओपन सोर्स टूल्स और मॉडल्स

#!/usr/bin/env python3
"""
Ollama + LangChain का उपयोग करके लोकल रिसर्च एजेंट
पूर्वापेक्षाएं:
  - ollama serve (बैकग्राउंड में चल रहा हो)
  - ollama pull mistral
  - pip install langchain langchain-ollama langchain-community duckduckgo-search
"""

import json
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain.agents import AgentExecutor, create_react_agent
from duckduckgo_search import DDGS


@tool
def search_web(query: str) -> str:
    """DuckDuckGo का उपयोग करके वेब पर जानकारी खोजें।"""
    try:
        with DDGS() as ddgs:
            results = list(ddgs.text(query, max_results=5))
        if not results:
            return "कोई परिणाम नहीं मिला।"
        return json.dumps(
            [{"title": r["title"], "snippet": r["body"], "url": r["href"]}
             for r in results],
            indent=2, ensure_ascii=False
        )
    except Exception as e:
        return f"खोज विफल: {e}"


@tool
def read_file(filepath: str) -> str:
    """लोकल फाइल पढ़ें और उसकी सामग्री लौटाएं।"""
    try:
        with open(filepath, "r") as f:
            return f.read()
    except FileNotFoundError:
        return f"फाइल नहीं मिली: {filepath}"


@tool
def calculate(expression: str) -> str:
    """सुरक्षित रूप से एक साधारण अंकगणितीय अभिव्यक्ति का मूल्यांकन करें।"""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"गणना त्रुटि: {e}"


llm = ChatOllama(
    model="mistral",
    base_url="http://localhost:11434",
    temperature=0.3,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", """आप एक रिसर्च असिस्टेंट हैं। अपने टूल्स का उपयोग करके सवालों का जवाब दें।

उपलब्ध टूल्स: {tool_names}
टूल विवरण: {tools}

इस प्रारूप का बिल्कुल पालन करें:
Thought: मुझे क्या पता लगाना है?
Action: tool_name
Action Input: टूल के लिए इनपुट
Observation: टूल परिणाम
... (आवश्यकतानुसार दोहराएं)
Thought: अब मेरे पास पर्याप्त जानकारी है।
Final Answer: आपका पूरा जवाब"""),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

tools = [search_web, read_file, calculate]
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,
    handle_parsing_errors=True,
)

if __name__ == "__main__":
    result = agent_executor.invoke({
        "input": "अभी तीन सबसे लोकप्रिय ओपन सोर्स LLM कौन से हैं? नाम और प्रत्येक की एक मुख्य विशेषता दें।"
    })
    print(f"\nअंतिम उत्तर:\n{result['output']}")

import sqlite3

@tool
def query_database(sql: str) -> str:
    """लोकल डेटाबेस पर रीड-ओनली SQL क्वेरी चलाएं।"""
    try:
        conn = sqlite3.connect("data.db")
        cursor = conn.cursor()
        cursor.execute(sql)
        rows = cursor.fetchall()
        columns = [desc[0] for desc in cursor.description]
        conn.close()
        return json.dumps([dict(zip(columns, row)) for row in rows], indent=2)
    except Exception as e:
        return f"डेटाबेस त्रुटि: {e}"

from sentence_transformers import SentenceTransformer
import chromadb

model = SentenceTransformer("all-MiniLM-L6-v2")
client = chromadb.Client()
collection = client.create_collection("docs")

@tool
def search_docs(query: str) -> str:
    """सिमेंटिक समानता से लोकल डॉक्यूमेंट खोजें।"""
    results = collection.query(
        query_embeddings=[model.encode(query).tolist()],
        n_results=3
    )
    return json.dumps(results["documents"][0], indent=2)

FROM python:3.12-slim
RUN pip install langchain langchain-ollama langchain-community duckduckgo-search
COPY research_agent.py .
ENV OLLAMA_HOST=host.docker.internal:11434
CMD ["python3", "research_agent.py"]

def run_pipeline(question: str) -> str:
    research_result = researcher.invoke({"input": question})
    final_output = writer.invoke({
        "input": f"इस रिसर्च के आधार पर एक स्पष्ट सारांश लिखें:\n{research_result['output']}"
    })
    return final_output["output"]