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

ollama --version

# Pull the Mistral model (recommended starting model)
ollama pull mistral

# Optional: Pull additional models
ollama pull llama3
ollama pull mixtral

ollama list

git clone https://github.com/kliewerdaniel/simulacra01.git
cd simulacra01
pip install -e .

pip install -r requirements.txt

python -c "from ollama_client import OllamaClient; client = OllamaClient(); response = client.chat.completions.create(model='mistral', messages=[{'role': 'user', 'content': 'Hello, world!'}]); print(response.choices[0].message.content)"

python main.py

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

You: Extract all the dates mentioned in the last document.

You: Find information about neural networks in the document.

fetch_document(url="https://example.com/article")

extract_info(text="document content", info_type="dates")

search_document(text="document content", query="neural networks")

from document_memory import DocumentMemory

# Initialize memory
memory = DocumentMemory()

# Store a document
doc_id = memory.store_document(
    url="https://example.com/article",
    content="Document text goes here...",
    metadata={"author": "John Doe", "date": "2025-03-13"}
)

# Retrieve a document
doc = memory.get_document(doc_id)
print(doc["content"])

# List all documents
docs = memory.list_documents()
for doc in docs:
    print(f"URL: {doc['url']}")

# Start with interactive menu
python cli.py

# Start directly with a specific agent
python cli.py chat --agent document
python cli.py chat --agent research

python cli.py config

from agents import Agent, function_tool
from ollama_client import OllamaClient
from pydantic import BaseModel, Field

# Define the client
client = OllamaClient(model_name="mistral")

# Define tool schemas
class AddInput(BaseModel):
    a: int = Field(..., description="First number")
    b: int = Field(..., description="Second number")

class AddOutput(BaseModel):
    result: int = Field(..., description="Sum of the two numbers")

# Define the tool function
@function_tool
def add(a: int, b: int) -> dict:
    """Adds two numbers together."""
    return {"result": a + b}

# Create the agent
agent = Agent(
    name="MathAgent",
    instructions="You are a math assistant that helps users with calculations.",
    tools=[add],
    model=client,
)

# Use the agent
response = agent.run("What is 5 + 7?")
print(response.message)

from agents import Agent, function_tool
from ollama_client import OllamaClient
from pydantic import BaseModel, Field
import requests
import json
import re

class WeatherInput(BaseModel):
    location: str = Field(..., description="City or location name")

class WeatherOutput(BaseModel):
    temperature: float = Field(..., description="Current temperature in Celsius")
    conditions: str = Field(..., description="Weather conditions")
    humidity: float = Field(..., description="Humidity percentage")

class ForecastInput(BaseModel):
    location: str = Field(..., description="City or location name")
    days: int = Field(3, description="Number of days to forecast")

class ForecastOutput(BaseModel):
    forecast: list = Field(..., description="Daily forecast data")

@function_tool
def get_weather(location: str) -> dict:
    """Gets the current weather for a location."""
    try:
        # Example implementation (would use actual weather API)
        response = requests.get(f"https://weather-api.example.com/current?q={location}")
        data = response.json()
        return {
            "temperature": data["temp_c"],
            "conditions": data["condition"]["text"],
            "humidity": data["humidity"]
        }
    except Exception as e:
        return {"error": str(e)}

@function_tool
def get_forecast(location: str, days: int = 3) -> dict:
    """Gets a weather forecast for a location."""
    try:
        # Example implementation (would use actual weather API)
        response = requests.get(f"https://weather-api.example.com/forecast?q={location}&days={days}")
        data = response.json()
        forecast = []
        for day in data["forecast"]["forecastday"]:
            forecast.append({
                "date": day["date"],
                "max_temp": day["day"]["maxtemp_c"],
                "min_temp": day["day"]["mintemp_c"],
                "condition": day["day"]["condition"]["text"]
            })
        return {"forecast": forecast}
    except Exception as e:
        return {"error": str(e)}

def create_weather_agent():
    """Creates a weather information agent."""
    client = OllamaClient(model_name="mistral")
    
    agent = Agent(
        name="WeatherAgent",
        instructions="""
        You are a Weather Assistant that provides accurate weather information.
        
        When a user asks about the weather:
        1. Use get_weather to fetch current conditions
        2. Use get_forecast for multi-day forecasts
        
        Always specify temperature units (Celsius) in your responses.
        For forecasts, present the information in a clear, day-by-day format.
        If a user doesn't specify a location, ask them for clarification.
        """,
        tools=[get_weather, get_forecast],
        model=client,
    )
    
    return agent

# Usage
agent = create_weather_agent()
response = agent.run("What's the weather like in London?")
print(response.message)

ollama pull llama3

client = OllamaClient(model_name="llama3")

agent = Agent(
    name="CustomAgent",
    instructions="""
    You are a specialized assistant that helps with [specific domain].
    
    Follow these guidelines:
    1. Always begin by [specific action]
    2. For complex queries, use [specific approach]
    3. When uncertain, [specific strategy]
    
    When using tools:
    - Use [tool1] for [specific scenario]
    - Use [tool2] when [specific condition]
    
    Response format:
    - Start with a [specific element]
    - Include [specific component]
    - Format using [specific style]
    
    Additional instructions:
    [any other specific behavioral guidance]
    """,
    tools=tools,
    model=client,
)

from caching_service import CachingService
from ollama_client import OllamaClient

# Create a caching layer
cache = CachingService(cache_dir="./cache")

# Create a cached client
class CachedOllamaClient(OllamaClient):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.cache = cache
    
    def chat_completion(self, messages, **kwargs):
        cache_key = self._generate_cache_key(messages, kwargs)
        cached_result = self.cache.get(cache_key)
        
        if cached_result:
            return cached_result
        
        result = super().chat_completion(messages, **kwargs)
        self.cache.store(cache_key, result)
        
        return result
    
    def _generate_cache_key(self, messages, kwargs):
        # Create a deterministic key from messages and relevant kwargs
        key_components = [
            self.model_name,
            str(messages),
            str({k: v for k, v in kwargs.items() if k in ["temperature", "max_tokens"]})
        ]
        return hash("".join(key_components))

# Use the cached client
client = CachedOllamaClient(model_name="mistral")

from agents import Agent, function_tool
from ollama_client import OllamaClient

# Document tools
@function_tool(category="document")
def fetch_document(url: str) -> dict:
    """Fetches a document from URL."""
    # Implementation

@function_tool(category="document")
def analyze_document(text: str) -> dict:
    """Analyzes document content."""
    # Implementation

# Search tools
@function_tool(category="search")
def web_search(query: str) -> dict:
    """Searches the web for information."""
    # Implementation

@function_tool(category="search")
def image_search(query: str) -> dict:
    """Searches for images."""
    # Implementation

# Create an agent with tool categories
client = OllamaClient(model_name="mixtral")

agent = Agent(
    name="ResearchAssistant",
    instructions="""
    You are a Research Assistant with access to different tool categories:
    
    DOCUMENT TOOLS:
    - Use fetch_document to retrieve document content
    - Use analyze_document to extract insights from documents
    
    SEARCH TOOLS:
    - Use web_search to find information online
    - Use image_search to find relevant images
    
    Choose the appropriate tool category based on the user's request.
    """,
    tools=[fetch_document, analyze_document, web_search, image_search],
    model=client,
)

class CustomAgentResponse:
    def __init__(self, result):
        self.message = self._format_message(result.final_output)
        self.conversation_id = getattr(result, 'conversation_id', None)
        self.tool_calls = self._extract_tool_calls(result)
        self.formatted_output = self._generate_formatted_output()
        
    def _format_message(self, message):
        # Format the message (e.g., add markdown, structure sections)
        return message
        
    def _extract_tool_calls(self, result):
        # Extract tool call information
        tool_calls = []
        # Extraction logic
        return tool_calls
        
    def _generate_formatted_output(self):
        # Create a custom formatted output (e.g., HTML, JSON)
        return {
            "message": self.message,
            "tools_used": [t.name for t in self.tool_calls],
            "formatted_at": datetime.now().isoformat()
        }
        
    def to_json(self):
        """Convert the response to JSON."""
        return json.dumps(self.formatted_output)
        
    def to_html(self):
        """Convert the response to HTML."""
        html = f"<div class='agent-response'><p>{self.message}</p>"
        if self.tool_calls:
            html += "<ul class='tools-used'>"
            for tool in self.tool_calls:
                html += f"<li>{tool.name}</li>"
            html += "</ul>"
        html += "</div>"
        return html

import logging
import sys

# Configure logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("simulacra01.log"),
        logging.StreamHandler(sys.stdout)
    ]
)

# Create module-specific loggers
ollama_logger = logging.getLogger("ollama_client")
agent_logger = logging.getLogger("agent")
tools_logger = logging.getLogger("tools")

# Set specific log levels if needed
ollama_logger.setLevel(logging.DEBUG)

from ollama_client import OllamaClient

client = OllamaClient(model_name="mistral")

# Get raw response
response = client.chat.completions.create(
    model="mistral",
    messages=[{"role": "user", "content": "What is 2+2?"}],
    temperature=0.7,
)

# Print full response object
import json
print(json.dumps(response.model_dump(), indent=2))

def chunk_document(text, chunk_size=2000, overlap=200):
    """Split document into overlapping chunks."""
    chunks = []
    
    # Simple character-based chunking
    for i in range(0, len(text), chunk_size - overlap):
        chunk = text[i:i + chunk_size]
        chunks.append(chunk)
    
    return chunks

def chunk_document_by_section(text, chunk_size=2000):
    """Split document by natural section boundaries."""
    # Find section boundaries (e.g., headers, paragraph breaks)
    sections = re.split(r'(?:\n\s*){2,}|(?:#{1,6}\s+[^\n]+\n)', text)
    
    chunks = []
    current_chunk = ""
    
    for section in sections:
        # If adding this section would exceed chunk size, save current chunk
        if len(current_chunk) + len(section) > chunk_size and current_chunk:
            chunks.append(current_chunk)
            current_chunk = section
        else:
            current_chunk += section
    
    # Add the final chunk if not empty
    if current_chunk:
        chunks.append(current_chunk)
    
    return chunks

class MultiLevelCache:
    def __init__(self):
        self.memory_cache = {}  # Fast, in-memory cache
        self.disk_cache = DiskCache("./cache")  # Persistent disk cache
        
    def get(self, key):
        # First check memory cache (fastest)
        if key in self.memory_cache:
            return self.memory_cache[key]
        
        # Then check disk cache
        disk_result = self.disk_cache.get(key)
        if disk_result:
            # Also store in memory for future fast access
            self.memory_cache[key] = disk_result
            return disk_result
        
        return None
        
    def store(self, key, value):
        # Store in both caches
        self.memory_cache[key] = value
        self.disk_cache.store(key, value)
        
    def clear_memory_cache(self):
        """Clear only memory cache (e.g., to free memory)."""
        self.memory_cache = {}

import concurrent.futures

def process_document_parallel(document, queries):
    """Process multiple queries against a document in parallel."""
    results = {}
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        # Create a future for each query
        future_to_query = {
            executor.submit(search_document, document, query): query
            for query in queries
        }
        
        # Process results as they complete
        for future in concurrent.futures.as_completed(future_to_query):
            query = future_to_query[future]
            try:
                results[query] = future.result()
            except Exception as e:
                results[query] = {"error": str(e)}
                
    return results

# Clone the repository
git clone https://github.com/yourusername/simulacra01.git
cd simulacra01

# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install in development mode with dev dependencies
pip install -e ".[dev]"

# Install pre-commit hooks
pre-commit install

# Run all tests
pytest

# Run specific test file
pytest tests/test_ollama_client.py

# Run with coverage
coverage run -m pytest
coverage report
coverage html  # Generate HTML report

# Check code style
ruff check .

# Auto-fix issues
ruff check --fix .

# Run type checking
mypy .

# Generate API documentation
python scripts/generate_docs.py

# Build documentation website
mkdocs build

# Serve documentation locally
mkdocs serve