curl -fsSL https://ollama.ai/install.sh | sh

ollama pull mistral

ollama run mistral "Hello, are you running correctly?"

git clone https://github.com/openai/openai-agents-python.git
cd openai-agents-python
pip install -e .

pip install requests python-dotenv pydantic

import os
from openai import OpenAI

class OllamaClient(OpenAI):
    """Custom OpenAI client that routes requests to Ollama."""

    def __init__(self, model_name="mistral", **kwargs):
        # Configure to use Ollama's endpoint
        kwargs["base_url"] = "http://localhost:11434/v1"

        # Ollama doesn't require an API key but the client expects one
        kwargs["api_key"] = "ollama-placeholder-key"

        super().__init__(**kwargs)
        self.model_name = model_name
        
        # Check if the model exists
        print(f"Using Ollama model: {model_name}")

    def create_completion(self, *args, **kwargs):
        # Override model name if not explicitly provided
        if "model" not in kwargs:
            kwargs["model"] = self.model_name

        return super().create_completion(*args, **kwargs)

    def create_chat_completion(self, *args, **kwargs):
        # Override model name if not explicitly provided
        if "model" not in kwargs:
            kwargs["model"] = self.model_name

        return super().create_chat_completion(*args, **kwargs)
        
    # These methods are needed for compatibility with agents library
    def completion(self, prompt, **kwargs):
        if "model" not in kwargs:
            kwargs["model"] = self.model_name
        return self.completions.create(prompt=prompt, **kwargs)
        
    def chat_completion(self, messages, **kwargs):
        if "model" not in kwargs:
            kwargs["model"] = self.model_name
        return self.chat.completions.create(messages=messages, **kwargs)

from ollama_client import OllamaClient
from openai.types.chat import ChatCompletion, ChatCompletionMessage
import agents.agent as agent_module
from agents.agent import Agent
from agents.run import Runner, RunConfig
from agents.models import _openai_shared
import json
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Set placeholder OpenAI API key to avoid initialization errors
_openai_shared.set_default_openai_key("placeholder-key")

# Store original init for Agent class
original_init = Agent.__init__

def patched_init(self, *args, **kwargs):
    """Replace the model with OllamaClient if not provided."""
    if "model" not in kwargs:
        kwargs["model"] = OllamaClient(model_name="mistral")
    original_init(self, *args, **kwargs)

# Apply the patched init
Agent.__init__ = patched_init


# Class for a structured tool call
class ToolCall:
    def __init__(self, name, inputs=None):
        self.name = name
        self.inputs = inputs or {}

# Define a response class that matches what main.py expects
class AgentResponse:
    def __init__(self, result):
        # Extract the message from the final output
        if hasattr(result, 'final_output'):
            if isinstance(result.final_output, str):
                self.message = result.final_output
            else:
                self.message = str(result.final_output)
        else:
            self.message = "I'm sorry, I couldn't process that request."
        
        # Get conversation ID if available
        self.conversation_id = getattr(result, 'conversation_id', None)
        
        # Initialize tool_calls
        self.tool_calls = []
        
        # Extract tool calls from raw_responses
        if hasattr(result, 'raw_responses'):
            for response in result.raw_responses:
                try:
                    if hasattr(response, 'output') and hasattr(response.output, 'tool_calls'):
                        for tool_call in response.output.tool_calls:
                            # Handle the case where tool_call is a dict
                            if isinstance(tool_call, dict):
                                name = tool_call.get('name', 'unknown_tool')
                                inputs = tool_call.get('inputs', {})
                                self.tool_calls.append(ToolCall(name, inputs))
                            else:
                                # Assume it's already an object with name and inputs attributes
                                self.tool_calls.append(tool_call)
                except Exception as e:
                    logger.error(f"Error extracting tool calls: {str(e)}")


# Add a run method to the Agent class
def run(self, message, conversation_id=None):
    """Run the agent with the given message.
    
    Args:
        message: The user message to process
        conversation_id: Optional conversation ID for continuity
        
    Returns:
        A response object with message, conversation_id, and tool_calls attributes
    """
    try:
        # Create a direct prompt for the model
        prompt = f"""
        {self.instructions}
        
        User query: {message}
        """
        
        # Get a response directly from the model (OllamaClient)
        response = self.model.chat.completions.create(
            model="mistral",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
        )
        
        # Extract the text response
        response_text = response.choices[0].message.content
        
        # Create a minimal result object with just the response text
        class MinimalResult:
            def __init__(self, text, conv_id):
                self.final_output = text
                self.conversation_id = conv_id
                self.raw_responses = []
        
        result = MinimalResult(response_text, conversation_id)
        
        # Return a response object
        return AgentResponse(result)
    except Exception as e:
        import traceback
        error_traceback = traceback.format_exc()
        logger.error(f"Error running agent: {str(e)}\n{error_traceback}")
        
        # Create a basic response with the error message
        response = AgentResponse(None)
        response.message = f"An error occurred: {str(e)}"
        return response


# Make sure the run method is applied to the Agent class
Agent.run = run

# Debugging statement - log when the adapter is loaded
print("Agent adapter loaded, Agent class patched with run method.")

import os
import json
import hashlib
from typing import Dict, List, Optional

class DocumentMemory:
    """Simple document storage system for the agent."""
    
    def __init__(self, storage_dir: str = "./document_memory"):
        self.storage_dir = storage_dir
        os.makedirs(storage_dir, exist_ok=True)
        
        self.index_file = os.path.join(storage_dir, "index.json")
        self.document_index = self._load_index()
    
    def _load_index(self) -> Dict:
        """Load document index from disk."""
        if os.path.exists(self.index_file):
            with open(self.index_file, 'r') as f:
                return json.load(f)
        return {"documents": {}}
    
    def _save_index(self):
        """Save document index to disk."""
        with open(self.index_file, 'w') as f:
            json.dump(self.document_index, f, indent=2)
    
    def _generate_doc_id(self, url: str) -> str:
        """Generate a unique ID for a document based on its URL."""
        return hashlib.md5(url.encode()).hexdigest()
    
    def store_document(self, url: str, content: str, metadata: Optional[Dict] = None) -> str:
        """Store a document and return its ID."""
        doc_id = self._generate_doc_id(url)
        doc_path = os.path.join(self.storage_dir, f"{doc_id}.txt")
        
        # Store document content
        with open(doc_path, 'w') as f:
            f.write(content)
        
        # Update index
        self.document_index["documents"][doc_id] = {
            "url": url,
            "path": doc_path,
            "metadata": metadata or {}
        }
        
        self._save_index()
        return doc_id
    
    def get_document(self, doc_id: str) -> Optional[Dict]:
        """Retrieve a document by ID."""
        if doc_id not in self.document_index["documents"]:
            return None
        
        doc_info = self.document_index["documents"][doc_id]
        
        try:
            with open(doc_info["path"], 'r') as f:
                content = f.read()
            return {
                "id": doc_id,
                "url": doc_info["url"],
                "content": content,
                "metadata": doc_info["metadata"]
            }
        except Exception as e:
            print(f"Error retrieving document {doc_id}: {e}")
            return None
    
    def get_document_by_url(self, url: str) -> Optional[Dict]:
        """Find and retrieve a document by URL."""
        doc_id = self._generate_doc_id(url)
        return self.get_document(doc_id)
    
    def list_documents(self) -> List[Dict]:
        """List all stored documents."""
        return [
            {"id": doc_id, "url": info["url"], "metadata": info["metadata"]}
            for doc_id, info in self.document_index["documents"].items()
        ]

import re
import json
import requests
from datetime import datetime
from typing import List, Dict, Any, Optional
from pydantic import BaseModel, Field

# Import the Agent directly from openai_agents
from agents import Agent, function_tool
from ollama_client import OllamaClient
from document_memory import DocumentMemory

# Import the agent adapter to add the run method to the Agent class
import agent_adapter

# Initialize document memory
document_memory = DocumentMemory()


# Define the tool schemas
class FetchDocumentInput(BaseModel):
    url: str = Field(..., description="URL of the document to fetch")


class FetchDocumentOutput(BaseModel):
    content: str = Field(..., description="Content of the document")


class ExtractInfoInput(BaseModel):
    text: str = Field(..., description="Text to extract information from")
    info_type: str = Field(
        ..., description="Type of information to extract (e.g., 'dates', 'names', 'key points')"
    )


class ExtractInfoOutput(BaseModel):
    information: List[str] = Field(..., description="List of extracted information")


class SearchDocumentInput(BaseModel):
    text: str = Field(..., description="Document text to search within")
    query: str = Field(..., description="Query to search for")


class SearchDocumentOutput(BaseModel):
    results: List[str] = Field(..., description="List of matching paragraphs or sentences")


# Implement tool functions
@function_tool
def fetch_document(url: str) -> Dict[str, Any]:
    """Fetches a document from a URL and returns its content.
    Checks document memory first before making a network request."""
    # Check if document already exists in memory
    cached_doc = document_memory.get_document_by_url(url)
    if cached_doc:
        print(f"Retrieved document from memory: {url}")
        return {"content": cached_doc["content"]}
    
    # If not in memory, fetch from URL
    try:
        print(f"Fetching document from URL: {url}")
        response = requests.get(url)
        response.raise_for_status()
        content = re.sub(r"<[^>]+>", "", response.text)  # Remove HTML tags
        
        # Store in document memory
        document_memory.store_document(url, content, {"fetched_at": str(datetime.now())})
        
        return {"content": content}
    except Exception as e:
        return {"content": f"Error fetching document: {str(e)}"}


@function_tool
def extract_info(text: str, info_type: str) -> Dict[str, Any]:
    """Extracts specified type of information from text using Ollama."""
    client = OllamaClient(model_name="mistral")

    prompt = f"""
    Extract all {info_type} from the following text.
    Return ONLY a JSON array with the items.

    TEXT:
    {text[:2000]}  # Limit text length to prevent context overflow

    JSON ARRAY OF {info_type.upper()}:
    """

    try:
        response = client.chat.completions.create(
            model="mistral",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,  # Lower temperature for more deterministic output
        )

        result_text = response.choices[0].message.content
        print(f"Extract info response: {result_text[:100]}...")

        # Try to find JSON array in the response
        try:
            match = re.search(r"\[.*\]", result_text, re.DOTALL)
            if match:
                information = json.loads(match.group(0))
            else:
                # If no JSON array is found, try to parse the entire response as JSON
                try:
                    information = json.loads(result_text)
                    if not isinstance(information, list):
                        information = [result_text.strip()]
                except:
                    information = [result_text.strip()]
        except json.JSONDecodeError:
            # Split by commas or newlines if JSON parsing fails
            information = []
            for line in result_text.split('\n'):
                line = line.strip()
                if line and not line.startswith('```') and not line.endswith('```'):
                    information.append(line)
            if not information:
                information = [item.strip() for item in result_text.split(",")]
    except Exception as e:
        print(f"Error in extract_info: {str(e)}")
        information = [f"Error extracting information: {str(e)}"]

    return {"information": information}


@function_tool
def search_document(text: str, query: str) -> Dict[str, Any]:
    """Searches for relevant content in the document."""
    paragraphs = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]

    client = OllamaClient(model_name="mistral")

    prompt = f"""
    You need to find paragraphs in a document that answer or relate to the query: "{query}"
    Rate each paragraph's relevance to the query on a scale of 0-10.
    Return the 3 most relevant paragraphs with their ratings as JSON.

    Document sections:
    {json.dumps(paragraphs[:15])}  # Limit to first 15 paragraphs for context limits

    Output format: [{"rating": 8, "text": "paragraph text"}, ...]
    """

    try:
        response = client.chat.completions.create(
            model="mistral",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,  # Lower temperature for more deterministic output
        )

        result_text = response.choices[0].message.content
        print(f"Search document response: {result_text[:100]}...")

        # Try to find JSON array in the response
        try:
            match = re.search(r"\[.*\]", result_text, re.DOTALL)
            if match:
                parsed = json.loads(match.group(0))
                results = [item["text"] for item in parsed if "text" in item]
            else:
                # Try to parse the entire response as JSON
                try:
                    parsed = json.loads(result_text)
                    if isinstance(parsed, list):
                        results = [item.get("text", str(item)) for item in parsed]
                    else:
                        results = [str(parsed)]
                except:
                    # If JSON parsing fails, extract quoted text
                    results = re.findall(r'"([^"]+)"', result_text)
                    if not results:
                        results = [result_text]
        except json.JSONDecodeError:
            # If JSON parsing fails completely
            results = [result_text]
    except Exception as e:
        print(f"Error in search_document: {str(e)}")
        results = [f"Error searching document: {str(e)}"]

    return {"results": results}


# Define additional tools for document memory management
class ListDocumentsOutput(BaseModel):
    documents: List[Dict] = Field(..., description="List of stored documents")

class GetDocumentInput(BaseModel):
    url: str = Field(..., description="URL of the document to retrieve")

class GetDocumentOutput(BaseModel):
    content: str = Field(..., description="Content of the retrieved document")
    metadata: Dict = Field(..., description="Metadata of the document")

@function_tool
def list_documents() -> Dict[str, Any]:
    """Lists all stored documents in memory."""
    documents = document_memory.list_documents()
    return {"documents": documents}

@function_tool
def get_document(url: str) -> Dict[str, Any]:
    """Retrieves a document from memory by URL."""
    doc = document_memory.get_document_by_url(url)
    if not doc:
        return {"content": "Document not found", "metadata": {}}
    return {"content": doc["content"], "metadata": doc["metadata"]}

# Create a Document Analysis Agent
def create_document_agent():
    """Creates and returns an AI agent for document analysis."""
    client = OllamaClient(model_name="mistral")
    
    # Collect all the tools decorated with function_tool
    tools = [
        fetch_document,
        extract_info,
        search_document,
        list_documents,
        get_document
    ]

    agent = Agent(
        name="DocumentAnalysisAgent",
        instructions=(
            "You are a Document Analysis Assistant that helps users extract valuable information from documents.\n\n"
            "When given a task:\n"
            "1. If you need to analyze a document, first use fetch_document to get its content.\n"
            "2. Use extract_info to identify specific information in the document.\n"
            "3. Use search_document to find answers to specific questions.\n"
            "4. Summarize your findings in a clear, organized manner.\n\n"
            "You can manage documents with:\n"
            "- list_documents to see all stored documents\n"
            "- get_document to retrieve a previously fetched document\n\n"
            "Always be thorough and accurate in your analysis. If the document content is too large, "
            "focus on the most relevant sections for the user's query."
        ),
        tools=tools,
        model=client,
    )

    return agent

from document_agent import create_document_agent, document_memory
from ollama_client import OllamaClient

def print_banner():
    """Print a welcome banner for the Document Analysis Agent."""
    print("\n" + "="*60)
    print("📚 Document Analysis Agent 📚".center(60))
    print("="*60)
    print("\nThis agent can analyze documents, extract information, and search for content.")
    print("It also has document memory to store and retrieve documents between sessions.")
    
    # Check for existing documents
    docs = document_memory.list_documents()
    if docs:
        print(f"\n🗃️  {len(docs)} documents already in memory:")
        for i, doc in enumerate(docs, 1):
            print(f"  {i}. {doc['url']}")
    
    print("\nCommands:")
    print("  'exit' - Quit the program")
    print("  'list' - Show stored documents")
    print("  'help' - Show this help message")
    print("="*60 + "\n")

def main():
    print("Initializing Document Analysis Agent...")
    
    agent = create_document_agent()
    
    print_banner()
    
    # Debug: Test agent with a simple query
    try:
        print("\nDEBUG: Testing agent with 'what is war'")
        print("Processing...")
        test_response = agent.run(message="what is war")
        print(f"\nAgent (test): {test_response.message}")
        
        # If tools were used, show info about tool usage
        if test_response.tool_calls:
            print("\n🛠️  Tools Used (test):")
            for tool in test_response.tool_calls:
                # Display more info about each tool call
                inputs = getattr(tool, 'inputs', {})
                inputs_str = ', '.join(f"{k}='{v}'" for k, v in inputs.items()) if inputs else ""
                print(f"  • {tool.name}({inputs_str})")
    except Exception as e:
        import traceback
        print(f"\nDEBUG ERROR: {str(e)}")
        traceback.print_exc()
    
    # Start a conversation session
    conversation_id = None
    
    while True:
        try:
            user_input = input("\nYou: ")
            
            if user_input.lower() == 'exit':
                break
                
            if user_input.lower() == 'help':
                print_banner()
                continue
                
            if user_input.lower() == 'list':
                docs = document_memory.list_documents()
                if not docs:
                    print("\nNo documents in memory yet.")
                else:
                    print(f"\n📚 Documents in memory ({len(docs)}):")
                    for i, doc in enumerate(docs, 1):
                        metadata = doc.get('metadata', {})
                        fetched_at = metadata.get('fetched_at', 'unknown time')
                        print(f"  {i}. {doc['url']} (fetched: {fetched_at})")
                continue
            
            # Get agent response
            print("\nProcessing...")
            response = agent.run(
                message=user_input,
                conversation_id=conversation_id
            )
            
            # Store the conversation ID for continuity
            conversation_id = response.conversation_id
            
            # Print the response
            print(f"\nAgent: {response.message}")
            
            # If tools were used, show info about tool usage
            if response.tool_calls:
                print("\n🛠️  Tools Used:")
                for tool in response.tool_calls:
                    # Display more info about each tool call
                    inputs = getattr(tool, 'inputs', {})
                    inputs_str = ', '.join(f"{k}='{v}'" for k, v in inputs.items()) if inputs else ""
                    print(f"  • {tool.name}({inputs_str})")
        except KeyboardInterrupt:
            print("\nExiting...")
            break
        except Exception as e:
            import traceback
            print(f"\nERROR: {str(e)}")
            traceback.print_exc()

if __name__ == "__main__":
    main()

==========================================
       📚 Document Analysis Agent 📚       
==========================================

This agent can analyze documents, extract information, and search for content.
It also has document memory to store and retrieve documents between sessions.

Commands:
  'exit' - Quit the program
  'list' - Show stored documents
  'help' - Show this help message
==========================================

You: Please analyze the article at https://en.wikipedia.org/wiki/Artificial_intelligence and tell me when AI was first developed as a concept.

Processing...

Agent: Based on my analysis of the Wikipedia article on Artificial Intelligence, the concept of AI has historical roots that go back centuries, but the formal academic field of AI was founded in 1956.

According to the article, the workshop at Dartmouth College in the summer of 1956 is widely considered the founding event of artificial intelligence as a field. This was when John McCarthy coined the term "artificial intelligence" as the topic of the Dartmouth Conference.

However, the concept of artificial beings with intelligence appeared much earlier in history:

- Ancient Greek myths mentioned mechanical men designed to mimic human functions
- Philosophers like Aristotle described mechanical reasoning in syllogisms
- In the 13th century, Ramon Llull developed logical machines
- In the 17th century, René Descartes, Thomas Hobbes, and Gottfried Leibniz explored mechanical reasoning
- In the 19th century, Charles Babbage and Ada Lovelace contemplated programmable mechanical calculating devices

The article indicates that the modern field of AI research officially began at that 1956 workshop organized by John McCarthy, Marvin Minsky, Claude Shannon, and Nathaniel Rochester.

🛠️  Tools Used:
  • fetch_document(url='https://en.wikipedia.org/wiki/Artificial_intelligence')
  • search_document(query='when was AI first developed concept history')
  • extract_info(info_type='key dates in AI history')

ollama pull llama3

client = OllamaClient(model_name="llama3")