agent-implementation

Files (1)

• SKILL.md

SKILL.md (first lines)

# Agent Implementation

This skill provides comprehensive guidance for building AI agents, from basic patterns to advanced multi-agent systems.

## Core Concepts

### Agent Architecture
An agent consists of:
- **Reasoning Engine**: LLM for planning and decision making
- **Memory System**: Short-term (context) and long-term storage
- **Tool Registry**: Available functions/APIs
- **Execution Engine**: Runs tools and collects results
- **State Manager**: Tracks agent state across interactions

### Agent Types
1. **Reactive Agents**: Respond to user queries
2. **Proactive Agents**: Initiate actions autonomously
3. **Multi-Agent Systems**: Specialized agents collaborate
4. **Hierarchical Agents**: Manager oversees sub-agents

## Basic Agent Pattern

### 1. Simple Tool-Using Agent
```python
from openai import AsyncOpenAI

class ToolUsingAgent:
    """Simple agent that can call tools."""

    def __init__(self, api_key: str):
        self.client = AsyncOpenAI(api_key=api_key)
        self.tools = {
            "search": self.search_web,
            "calculate": self.calculate,
        }

    async def run(self, query: str) -> str:
        # Plan
        plan = await self.plan(query)

        # Execute
        result = await self.execute_plan(plan)

        return result

    async def plan(self, query: str) -> dict:
        """Create execution plan."""
        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a planning agent. Plan tool usage."},
                {"role": "user", "content": f"Plan how to: {query}"}
            ],
            tools=self.tool_list()
        )

        return self.parse_plan(response)

    async def execute_plan(self, plan: dict) -> str:
        """Execute the plan step by step."""
        results = []

        for step in plan["steps"]:
            tool = step["tool"]
            args = step["arguments"]

            if tool in self.tools:
                result = await self.tools[tool](**args)
                results.append(result)

        return "\n".join(results)

    def search_web(self, query: str) -> str:
        """Search the web for information."""
        # Implement web search
        return f"Search results for: {query}"

    def calculate(self, expression: str) -> float:
        """Evaluate mathematical expression."""
        try:
            return eval(expression)
        except:
            return f"Could not calculate: {expression}"
```

### 2. Stateful Agent
```python
from typing import TypedDict, Optional
from datetime import datetime

class AgentState(TypedDict):
    messages: list
    current_goal: Optional[str]
    plan: Optional[list]
    results: list
    metadata: dict

class StatefulAgent:
    """Agent with persistent state across interactions."""

    def __init__(self):
        self.state = AgentState(
            messages=[],
            current_goal=None,
            plan=None,
            results=[],
            metadata={"created_at": datetime.now().isoformat()}
        )

    async def process(self, user_input: str) -> str:
        """Process user input with state management."""
        self.state["messages"].append({"role": "user", "content": user_input})

        # Analyze goal
        if not self.state["current_goal"]:
            self.state["current_goal"] = await self.extract_goal(user_input)

        # Update plan if needed
        if not self.state["plan"]:

From yasinnerten/temporal-openai-agents-sdk, Apache-2.0.

More from yasinnerten/temporal-openai-agents-sdk