How to Build AI Agent Creator Platform with Ollama: Non-Expert Development Guide

# Download and install via homebrew
brew install ollama

# Or download directly from website
curl -fsSL https://ollama.ai/install.sh | sh

# Single command installation
curl -fsSL https://ollama.ai/install.sh | sh

# Check if Ollama installed correctly
ollama --version

# Start Ollama service
ollama serve

# Download a lightweight model for development
ollama pull llama2:7b

# For more capable responses (requires more RAM)
ollama pull llama2:13b

# Check downloaded models
ollama list

# Create main project directory
mkdir ai-agent-platform
cd ai-agent-platform

# Create subdirectories
mkdir -p {backend,frontend,agents,templates,config,logs}

# Initialize Python environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Create requirements file
touch requirements.txt

fastapi==0.104.1
uvicorn==0.24.0
requests==2.31.0
pydantic==2.5.0
python-multipart==0.0.6
jinja2==3.1.2
aiofiles==23.2.1
python-jose==3.3.0
passlib==1.7.4

pip install -r requirements.txt

from typing import Dict, List, Optional, Any
import json
import requests
from datetime import datetime

class AIAgent:
    """Base class for all AI agents in the platform."""
    
    def __init__(self, name: str, model: str = "llama2:7b", 
                 system_prompt: str = "", ollama_url: str = "http://localhost:11434"):
        self.name = name
        self.model = model
        self.system_prompt = system_prompt
        self.ollama_url = ollama_url
        self.conversation_history = []
        self.created_at = datetime.now()
        
    def send_message(self, message: str, context: Optional[Dict] = None) -> str:
        """Send a message to the agent and get response."""
        
        # Prepare the prompt with system instructions
        full_prompt = self._build_prompt(message, context)
        
        # Send request to Ollama
        try:
            response = requests.post(
                f"{self.ollama_url}/api/generate",
                json={
                    "model": self.model,
                    "prompt": full_prompt,
                    "stream": False
                },
                timeout=60
            )
            response.raise_for_status()
            
            # Extract response text
            result = response.json()
            agent_response = result.get("response", "")
            
            # Store conversation
            self.conversation_history.append({
                "timestamp": datetime.now().isoformat(),
                "user_message": message,
                "agent_response": agent_response,
                "context": context
            })
            
            return agent_response
            
        except requests.exceptions.RequestException as e:
            return f"Error communicating with agent: {str(e)}"
    
    def _build_prompt(self, message: str, context: Optional[Dict] = None) -> str:
        """Build the complete prompt including system instructions."""
        
        prompt_parts = []
        
        # Add system prompt if provided
        if self.system_prompt:
            prompt_parts.append(f"System: {self.system_prompt}")
        
        # Add context if provided
        if context:
            context_str = json.dumps(context, indent=2)
            prompt_parts.append(f"Context: {context_str}")
        
        # Add recent conversation history for continuity
        if self.conversation_history:
            recent_history = self.conversation_history[-3:]  # Last 3 exchanges
            for exchange in recent_history:
                prompt_parts.append(f"Previous User: {exchange['user_message']}")
                prompt_parts.append(f"Previous Assistant: {exchange['agent_response']}")
        
        # Add current message
        prompt_parts.append(f"User: {message}")
        prompt_parts.append("Assistant:")
        
        return "\n\n".join(prompt_parts)
    
    def get_stats(self) -> Dict[str, Any]:
        """Get agent statistics and information."""
        return {
            "name": self.name,
            "model": self.model,
            "created_at": self.created_at.isoformat(),
            "total_conversations": len(self.conversation_history),
            "system_prompt": self.system_prompt[:100] + "..." if len(self.system_prompt) > 100 else self.system_prompt
        }
    
    def export_conversations(self) -> List[Dict]:
        """Export conversation history for analysis."""
        return self.conversation_history.copy()

from typing import Dict, List, Optional
import json
import os
from .agent_base import AIAgent

class AgentManager:
    """Manages multiple AI agents and their configurations."""
    
    def __init__(self, config_dir: str = "config"):
        self.agents: Dict[str, AIAgent] = {}
        self.config_dir = config_dir
        self.templates_dir = "templates"
        
        # Ensure directories exist
        os.makedirs(config_dir, exist_ok=True)
        os.makedirs(self.templates_dir, exist_ok=True)
        
        # Load existing agents
        self._load_agents()
    
    def create_agent(self, name: str, template_name: str, 
                    custom_prompt: Optional[str] = None) -> bool:
        """Create a new agent from a template."""
        
        # Check if agent already exists
        if name in self.agents:
            return False
        
        # Load template
        template = self._load_template(template_name)
        if not template:
            return False
        
        # Use custom prompt or template prompt
        system_prompt = custom_prompt or template.get("system_prompt", "")
        
        # Create agent
        agent = AIAgent(
            name=name,
            model=template.get("model", "llama2:7b"),
            system_prompt=system_prompt
        )
        
        # Store agent
        self.agents[name] = agent
        
        # Save configuration
        self._save_agent_config(name, {
            "template": template_name,
            "model": agent.model,
            "system_prompt": system_prompt,
            "created_at": agent.created_at.isoformat()
        })
        
        return True
    
    def get_agent(self, name: str) -> Optional[AIAgent]:
        """Retrieve an agent by name."""
        return self.agents.get(name)
    
    def list_agents(self) -> List[Dict]:
        """List all agents with their basic information."""
        return [agent.get_stats() for agent in self.agents.values()]
    
    def delete_agent(self, name: str) -> bool:
        """Delete an agent and its configuration."""
        if name not in self.agents:
            return False
        
        # Remove from memory
        del self.agents[name]
        
        # Remove config file
        config_path = os.path.join(self.config_dir, f"{name}.json")
        if os.path.exists(config_path):
            os.remove(config_path)
        
        return True
    
    def _load_template(self, template_name: str) -> Optional[Dict]:
        """Load an agent template."""
        template_path = os.path.join(self.templates_dir, f"{template_name}.json")
        
        if not os.path.exists(template_path):
            return None
        
        try:
            with open(template_path, 'r') as f:
                return json.load(f)
        except (json.JSONDecodeError, IOError):
            return None
    
    def _save_agent_config(self, name: str, config: Dict):
        """Save agent configuration to file."""
        config_path = os.path.join(self.config_dir, f"{name}.json")
        
        try:
            with open(config_path, 'w') as f:
                json.dump(config, f, indent=2)
        except IOError:
            pass  # Handle error appropriately in production
    
    def _load_agents(self):
        """Load existing agents from configuration files."""
        if not os.path.exists(self.config_dir):
            return
        
        for filename in os.listdir(self.config_dir):
            if filename.endswith('.json'):
                name = filename[:-5]  # Remove .json extension
                config_path = os.path.join(self.config_dir, filename)
                
                try:
                    with open(config_path, 'r') as f:
                        config = json.load(f)
                    
                    # Recreate agent
                    agent = AIAgent(
                        name=name,
                        model=config.get("model", "llama2:7b"),
                        system_prompt=config.get("system_prompt", "")
                    )
                    
                    self.agents[name] = agent
                    
                except (json.JSONDecodeError, IOError):
                    continue  # Skip corrupted config files

{
  "name": "Customer Support Agent",
  "description": "Handles customer inquiries with empathy and efficiency",
  "model": "llama2:7b",
  "system_prompt": "You are a helpful customer support representative. Always be polite, empathetic, and solution-focused. If you cannot resolve an issue, escalate it appropriately. Keep responses concise but thorough. Ask clarifying questions when needed.",
  "sample_interactions": [
    {
      "user": "My order hasn't arrived yet",
      "agent": "I understand your concern about your delayed order. Let me help you track it. Could you please provide your order number?"
    }
  ],
  "capabilities": [
    "Order tracking",
    "Issue resolution",
    "Product information",
    "Escalation handling"
  ]
}

{
  "name": "Code Review Agent",
  "description": "Reviews code for best practices, bugs, and improvements",
  "model": "codellama:7b",
  "system_prompt": "You are an experienced software developer conducting code reviews. Focus on:\n1. Code quality and readability\n2. Potential bugs or security issues\n3. Performance optimization opportunities\n4. Best practices and conventions\n5. Constructive feedback with specific suggestions\n\nProvide clear, actionable feedback. Highlight both strengths and areas for improvement.",
  "sample_interactions": [
    {
      "user": "Please review this Python function for calculating fibonacci numbers",
      "agent": "I'll review your fibonacci function. Please share the code and I'll analyze it for efficiency, correctness, and best practices."
    }
  ],
  "capabilities": [
    "Code quality analysis",
    "Bug detection",
    "Performance review",
    "Best practices guidance"
  ]
}

{
  "name": "Content Writer Agent",
  "description": "Creates engaging content for blogs, marketing, and documentation",
  "model": "llama2:13b",
  "system_prompt": "You are a skilled content writer specializing in clear, engaging content. Your writing is:\n- Audience-appropriate and accessible\n- Well-structured with clear headings\n- SEO-friendly when requested\n- Factual and well-researched\n- Engaging and conversational\n\nAlways ask about target audience, tone, and specific requirements before writing.",
  "sample_interactions": [
    {
      "user": "Write a blog post about sustainable gardening",
      "agent": "I'd be happy to write about sustainable gardening! To create the best content for you, could you tell me: 1) Who's your target audience? 2) What's the desired length? 3) Any specific aspects of sustainable gardening to focus on?"
    }
  ],
  "capabilities": [
    "Blog post creation",
    "Marketing copy",
    "Technical documentation",
    "SEO optimization"
  ]
}

from fastapi import FastAPI, HTTPException, File, UploadFile
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
from typing import Optional, List, Dict
import os
import json

from .agent_manager import AgentManager

app = FastAPI(title="AI Agent Creator Platform", version="1.0.0")

# Enable CORS for frontend
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],  # React dev server
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize agent manager
agent_manager = AgentManager()

# Pydantic models for API
class CreateAgentRequest(BaseModel):
    name: str
    template_name: str
    custom_prompt: Optional[str] = None

class ChatMessage(BaseModel):
    agent_name: str
    message: str
    context: Optional[Dict] = None

class ChatResponse(BaseModel):
    response: str
    agent_name: str
    timestamp: str

@app.get("/")
async def root():
    return {"message": "AI Agent Creator Platform API"}

@app.get("/templates")
async def get_templates():
    """Get all available agent templates."""
    templates = []
    templates_dir = "templates"
    
    if os.path.exists(templates_dir):
        for filename in os.listdir(templates_dir):
            if filename.endswith('.json'):
                template_path = os.path.join(templates_dir, filename)
                try:
                    with open(template_path, 'r') as f:
                        template = json.load(f)
                        template['id'] = filename[:-5]  # Remove .json
                        templates.append(template)
                except (json.JSONDecodeError, IOError):
                    continue
    
    return {"templates": templates}

@app.post("/agents")
async def create_agent(request: CreateAgentRequest):
    """Create a new AI agent from a template."""
    
    success = agent_manager.create_agent(
        name=request.name,
        template_name=request.template_name,
        custom_prompt=request.custom_prompt
    )
    
    if not success:
        raise HTTPException(
            status_code=400, 
            detail="Agent creation failed. Name might already exist or template not found."
        )
    
    return {"message": f"Agent '{request.name}' created successfully"}

@app.get("/agents")
async def list_agents():
    """List all created agents."""
    agents = agent_manager.list_agents()
    return {"agents": agents}

@app.post("/chat")
async def chat_with_agent(message: ChatMessage) -> ChatResponse:
    """Send a message to an agent and get response."""
    
    agent = agent_manager.get_agent(message.agent_name)
    if not agent:
        raise HTTPException(status_code=404, detail="Agent not found")
    
    response = agent.send_message(message.message, message.context)
    
    return ChatResponse(
        response=response,
        agent_name=message.agent_name,
        timestamp=agent.conversation_history[-1]["timestamp"]
    )

@app.get("/agents/{agent_name}/stats")
async def get_agent_stats(agent_name: str):
    """Get statistics for a specific agent."""
    agent = agent_manager.get_agent(agent_name)
    if not agent:
        raise HTTPException(status_code=404, detail="Agent not found")
    
    return agent.get_stats()

@app.get("/agents/{agent_name}/conversations")
async def get_agent_conversations(agent_name: str):
    """Get conversation history for an agent."""
    agent = agent_manager.get_agent(agent_name)
    if not agent:
        raise HTTPException(status_code=404, detail="Agent not found")
    
    return {"conversations": agent.export_conversations()}

@app.delete("/agents/{agent_name}")
async def delete_agent(agent_name: str):
    """Delete an agent."""
    success = agent_manager.delete_agent(agent_name)
    if not success:
        raise HTTPException(status_code=404, detail="Agent not found")
    
    return {"message": f"Agent '{agent_name}' deleted successfully"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

# Navigate to frontend directory
cd frontend

# Initialize React app
npx create-react-app . --template typescript
npm install axios react-router-dom @types/react-router-dom

# Install UI components
npm install @mui/material @emotion/react @emotion/styled
npm install @mui/icons-material

import React, { useState, useEffect } from 'react';
import {
  Container,
  AppBar,
  Toolbar,
  Typography,
  Tab,
  Tabs,
  Box,
  Paper
} from '@mui/material';
import { BrowserRouter as Router, Routes, Route, Link } from 'react-router-dom';

import AgentList from './components/AgentList';
import CreateAgent from './components/CreateAgent';
import ChatInterface from './components/ChatInterface';
import './App.css';

interface TabPanelProps {
  children?: React.ReactNode;
  index: number;
  value: number;
}

function TabPanel(props: TabPanelProps) {
  const { children, value, index, ...other } = props;

  return (
    <div
      role="tabpanel"
      hidden={value !== index}
      id={`simple-tabpanel-${index}`}
      aria-labelledby={`simple-tab-${index}`}
      {...other}
    >
      {value === index && (
        <Box sx={{ p: 3 }}>
          {children}
        </Box>
      )}
    </div>
  );
}

function App() {
  const [tabValue, setTabValue] = useState(0);

  const handleTabChange = (event: React.SyntheticEvent, newValue: number) => {
    setTabValue(newValue);
  };

  return (
    <div className="App">
      <AppBar position="static">
        <Toolbar>
          <Typography variant="h6" component="div" sx={{ flexGrow: 1 }}>
            AI Agent Creator Platform
          </Typography>
        </Toolbar>
      </AppBar>

      <Container maxWidth="lg" sx={{ mt: 4 }}>
        <Paper elevation={3}>
          <Box sx={{ borderBottom: 1, borderColor: 'divider' }}>
            <Tabs value={tabValue} onChange={handleTabChange}>
              <Tab label="My Agents" />
              <Tab label="Create Agent" />
              <Tab label="Chat" />
            </Tabs>
          </Box>
          
          <TabPanel value={tabValue} index={0}>
            <AgentList />
          </TabPanel>
          
          <TabPanel value={tabValue} index={1}>
            <CreateAgent />
          </TabPanel>
          
          <TabPanel value={tabValue} index={2}>
            <ChatInterface />
          </TabPanel>
        </Paper>
      </Container>
    </div>
  );
}

export default App;

# Navigate to project root
cd ai-agent-platform

# Activate virtual environment
source venv/bin/activate

# Start Ollama (if not already running)
ollama serve

# Start FastAPI server
python -m uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000

# In a new terminal, navigate to frontend
cd ai-agent-platform/frontend

# Start React development server
npm start

# Update backend to accept external connections
python -m uvicorn backend.main:app --host 0.0.0.0 --port 8000

# Update frontend package.json
# Add to scripts section:
"start:network": "HOST=0.0.0.0 react-scripts start"

# Start frontend for network access
npm run start:network

# Check if Ollama is running
ps aux | grep ollama

# Start Ollama service
ollama serve

# Verify it's listening on correct port
curl http://localhost:11434/api/tags

# List available models
ollama list

# Download missing model
ollama pull llama2:7b

# Check download progress
ollama show llama2:7b

# Add memory monitoring to agent_base.py
import psutil

def check_memory_usage(self):
    """Check current memory usage before processing."""
    memory = psutil.virtual_memory()
    if memory.percent > 90:
        return "System memory usage too high. Please try again later."
    return None

# Example: Create a meeting scheduler agent
def create_scheduler_agent():
    system_prompt = """
    You are a meeting scheduler assistant. You help users:
    1. Find available time slots
    2. Send meeting invitations
    3. Handle scheduling conflicts
    4. Set reminders
    
    Always confirm details before finalizing meetings.
    Be proactive about potential scheduling issues.
    """
    
    return AIAgent(
        name="meeting_scheduler",
        system_prompt=system_prompt,
        model="llama2:7b"
    )

# Add to agent_base.py
import requests
from datetime import datetime, timedelta

def add_calendar_integration(self, calendar_api_key: str):
    """Add calendar integration to agent."""
    self.calendar_api_key = calendar_api_key
    
def check_availability(self, date: str, duration: int) -> List[str]:
    """Check calendar availability for given date."""
    # Implementation depends on your calendar service
    # This is a placeholder for Google Calendar API integration
    pass

# Agent manager enhancement
MODEL_RECOMMENDATIONS = {
    "customer_support": "llama2:7b",
    "code_reviewer": "codellama:7b", 
    "content_writer": "llama2:13b",
    "data_analyst": "llama2:13b"
}

def get_recommended_model(self, template_name: str) -> str:
    """Get recommended model for template type."""
    return MODEL_RECOMMENDATIONS.get(template_name, "llama2:7b")