Results Interpretation:

Sheppard Agency

Overview

Key Features

Memory System

Research System

LLM System

Installation

Requirements

Setup

git clone https://github.com/yourusername/sheppard_agency.git
cd sheppard_agency

python -m venv venv
source venv/bin/activate  # On Windows, use: venv\Scripts\activate

pip install -r requirements.txt

pip install firecrawl-py

# Ollama Configuration
OLLAMA_MODEL=mannix/dolphin-2.9-llama3-8b:latest
OLLAMA_EMBED_MODEL=mxbai-embed-large
OLLAMA_API_BASE=http://localhost:11434/api

# Redis Configuration
REDIS_HOST=localhost
REDIS_PORT=6379

# ChromaDB Configuration
CHROMADB_PERSIST_DIRECTORY=./data/chromadb
CHROMADB_DISTANCE_FUNC=cosine

# Research Configuration
FIRECRAWL_API_KEY=your_firecrawl_api_key  # Optional

# Application Directories
DATA_DIR=./data
LOG_DIR=./logs
SCREENSHOT_DIR=./screenshots
TEMP_DIR=./temp

# System Configuration
MAX_RETRIES=3
REQUEST_TIMEOUT=60
EMBEDDING_DIMENSION=384
GPU_ENABLED=false  # Set to true if GPU available

ollama pull mannix/dolphin-2.9-llama3-8b:latest
ollama pull mxbai-embed-large
ollama pull Azazel-AI/llama-3.2-1b-instruct-abliterated.q8_0
ollama pull llama3.1:latest
ollama pull krith/mistral-nemo-instruct-2407-abliterated:IQ3_M

mkdir -p data/chromadb logs screenshots temp research_results

# Linux/macOS
redis-server

# Windows (after installing Redis)
redis-server.exe

Running the Application

Method 1: Direct Execution

python main.py

Method 2: Using the ChatApp Interface

# Example script to run the chat application
import asyncio
from src.core.chat import ChatApp
from src.core.system import system_manager

async def main():
    # Initialize system components
    success, error = await system_manager.initialize()
    if not success:
        print(f"System initialization failed: {error}")
        return
        
    # Create chat app
    chat_app = ChatApp()
    
    # Initialize chat app with system components
    await chat_app.initialize(
        memory_system=system_manager.memory_manager,
        research_system=system_manager.research_system,
        llm_system=system_manager.ollama_client
    )
    
    # Example interaction
    async for response in chat_app.process_input("Tell me about quantum computing"):
        print(response.content)
        
    # Clean up resources
    await chat_app.close()
    await system_manager.cleanup()

# Run the main function
if __name__ == "__main__":
    asyncio.run(main())

Method 3: Using Command Line Interface

import asyncio
from rich.console import Console
from src.core.commands import CommandHandler
from src.core.system import system_manager

async def main():
    # Initialize console
    console = Console()
    
    # Initialize system
    success, error = await system_manager.initialize()
    if not success:
        console.print(f"System initialization failed: {error}", style="bold red")
        return
    
    # Create command handler
    command_handler = CommandHandler(console, system_manager)
    
    # Show welcome message
    command_handler.show_welcome()
    
    # Main interaction loop
    while True:
        # Display prompt
        console.print("[green]You:[/green] ", end="")
        user_input = input()
        
        # Check for exit command
        if user_input.lower() in ['/exit', '/quit']:
            break
            
        # Handle commands
        if user_input.startswith('/'):
            await command_handler.handle_command(user_input)
        else:
            # Process normal input through chat system
            responses = system_manager.ollama_client.chat(
                messages=[{"role": "user", "content": user_input}],
                stream=True
            )
            
            console.print("[blue]Assistant:[/blue] ", end="")
            async for response in responses:
                if hasattr(response, 'content') and response.content:
                    console.print(response.content, end="")
            console.print()
    
    # Clean up
    await system_manager.cleanup()
    console.print("Goodbye!", style="bold blue")

if __name__ == "__main__":
    asyncio.run(main())

Usage

Basic Interaction

> Tell me about quantum computing
> What was the last topic we discussed?
> I prefer explanations with examples
> Research the latest advancements in renewable energy

Commands

Using the Research System

Basic Research Command

/research quantum computing --depth=3

Using the ResearchSystem Programmatically

import asyncio
from src.research.system import ResearchSystem
from src.research.models import ResearchType
from rich.console import Console

async def research_example():
    console = Console()
    
    # Initialize research system
    research_system = ResearchSystem()
    await research_system.initialize()
    
    try:
        # Perform research
        console.print("Researching quantum computing...", style="bold blue")
        results = await research_system.research_topic(
            topic="quantum computing",
            research_type=ResearchType.WEB_SEARCH,
            depth=3
        )
        
        # Display results
        console.print(f"Found {len(results.get('findings', []))} findings")
        for finding in results.get('findings', []):
            console.print(f"[bold green]Source:[/bold green] {finding.get('url')}")
            console.print(f"[bold green]Title:[/bold green] {finding.get('title')}")
            console.print(f"[bold green]Summary:[/bold green] {finding.get('summary')}")
            console.print("---")
    
    finally:
        # Clean up
        await research_system.cleanup()

if __name__ == "__main__":
    asyncio.run(research_example())

Using Autonomous Browser Mode

from src.research.browser_control import AutonomousBrowser

# Initialize the autonomous browser
browser = AutonomousBrowser(
    headless=True,
    timeout=30,
    max_pages=5,
    auto_recovery=True,
    intelligent_retries=True
)
await browser.initialize()

# Use the intelligent navigation method
results = await browser.navigate_intelligently(
    query="quantum computing",
    depth=3,
    source_types=["scholarly", "scientific", "technical"],
    progress_callback=lambda p: print(f"Progress: {p*100:.0f}%")
)

# Analyze extracted information
print(f"Pages visited: {results['metadata']['pages_visited']}")
print(f"Domains visited: {results['metadata']['domains_visited']}")
for content in results['content']:
    print(f"URL: {content['url']}")
    print(f"Word count: {len(content.get('markdown', '').split())}")
    print("---")

# Cleanup when done
await browser.cleanup()

Deep Analysis Mode

# Create a task for deep analysis
task_id = await research_system.task_manager.create_task(
    description="quantum computing advancements",
    research_type=ResearchType.DEEP_ANALYSIS,
    depth=5,
    metadata={"require_citations": True}
)

# Process the task
await research_system.task_manager.process_task(task_id)

# Get the detailed results
deep_results = await research_system.perform_deep_research(
    task_id,
    validation_level=ValidationLevel.HIGH
)

# Display the analysis
print(deep_results['analysis']['text'])

Firecrawl Integration

from src.research.models import FirecrawlConfig
from src.research.system import ResearchSystem

# Create Firecrawl configuration
firecrawl_config = FirecrawlConfig(
    api_key="your_api_key_here",
    max_pages=10,
    formats=["markdown", "html"]
)

# Initialize research system with Firecrawl
research_system = ResearchSystem(
    memory_manager=memory_manager,
    ollama_client=ollama_client,
    config=ResearchConfig(firecrawl=firecrawl_config)
)
await research_system.initialize()

# Now research will use Firecrawl when available
results = await research_system.research_topic("quantum computing")

Memory Management

Memory Persistence

Context Summarization

Configuration Options

Memory System Settings

Research System Settings

LLM System Settings

Architecture

Troubleshooting

Common Issues:

Logs

Uploading Multiple Files and Directories as a Single Project

Method 1: Import Existing Directory Structure

1. First, create a new project
   /code project create MyProject "My application code"

2. Then import an entire directory structure
   /code import /path/to/your/local/directory

Method 2: Upload Files in Conversation

/code project create MyProject "Project using uploaded files"

# For each uploaded file, create it in your project
/code file save src/main.py [content of your main.py]
/code file save src/utils/helpers.py [content of your helpers.py]

Method 3: Batch Import for Large Projects

# Create a batch import command that processes a list of files
/code execute 

import os
from pathlib import Path

def batch_import(project_id, file_paths, base_dir=None):
    """Import multiple files into the project."""
    imported_files = []
    
    for file_path in file_paths:
        # Read content
        with open(file_path, 'r') as f:
            content = f.read()
        
        # Get relative path if base_dir is provided
        if base_dir:
            rel_path = os.path.relpath(file_path, base_dir)
        else:
            rel_path = os.path.basename(file_path)
        
        # Save to project
        success = code_arena.save_code_file(rel_path, content, project_id)
        if success:
            imported_files.append(rel_path)
    
    return imported_files

# Example usage:
project_id = "project_abc123"  # Your project ID
base_dir = "/home/user/myproject"
file_paths = [
    "/home/user/myproject/main.py",
    "/home/user/myproject/utils/helpers.py",
    "/home/user/myproject/data/processor.py"
]

imported = batch_import(project_id, file_paths, base_dir)
print(f"Imported {len(imported)} files")

Real Example: Importing the Current Project

# Step 1: Create a new project
/code project create SheppardChat "Sheppard Chat System with Memory and Research"

# Step 2: Import all the files you've shown me
/code import ~/sheppard-phoenix

# Step 3: Verify the import
/code file list "**/*.py"

# Step 4: Analyze the project structure
/code analyze

How the System Handles the Files

# Examine a specific file
/code file load src/memory/manager.py

# Execute a file
/code execute file src/main.py

# Discuss specific aspects
/code discuss How does the memory manager interface with the chat system?

# Generate new components that fit into your architecture
/code develop new_feature "Description of what you want to add"

Adding New Features

Contributing

Licensing