ai-agent

Files (5)

• SKILL.md
• agent-communication.md
• chat-interfaces.md
• openai-patterns.md
• advanced-patterns.md · references/

SKILL.md (first lines)

# AI Agent Development

Build multi-agent systems with OpenAI API, chat interfaces, and agent registries.

## Quick Start

### Project Structure

```
my-agent-project/
├── agents/
│   ├── base_agent.py          # Base agent class
│   ├── chat_agent.py          # Conversational agent
│   └── specialist_agent.py    # Domain-specific agent
├── registry/
│   ├── a2a_registry.py        # Agent-to-Agent registry
│   └── mcp_registry.py        # MCP server registry
├── interfaces/
│   ├── cli.py                 # CLI chat interface
│   ├── api.py                 # REST/WebSocket API
│   └── web/                   # React frontend
├── communication/
│   └── message_bus.py         # Inter-agent messaging
├── config/
│   └── settings.py            # Configuration
└── docker-compose.yml         # PostgreSQL + Redis
```

## Core Components

### 1. Base Agent (Python)

```python
from openai import OpenAI
from abc import ABC, abstractmethod
from typing import AsyncIterator
import json

class BaseAgent(ABC):
    def __init__(self, agent_id: str, name: str, model: str = "gpt-4o"):
        self.agent_id = agent_id
        self.name = name
        self.model = model
        self.client = OpenAI()
        self.system_prompt = self._build_system_prompt()
        self.conversation_history = []
    
    @abstractmethod
    def _build_system_prompt(self) -> str:
        """Define agent's personality and capabilities."""
        pass
    
    @abstractmethod
    def get_tools(self) -> list[dict]:
        """Define agent's available tools/functions."""
        pass
    
    async def chat(self, message: str) -> str:
        self.conversation_history.append({"role": "user", "content": message})
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": self.system_prompt},
                *self.conversation_history
            ],
            tools=self.get_tools() or None
        )
        
        assistant_message = response.choices[0].message
        
        # Handle tool calls
        if assistant_message.tool_calls:
            return await self._handle_tool_calls(assistant_message)
        
        self.conversation_history.append({
            "role": "assistant", 
            "content": assistant_message.content
        })
        return assistant_message.content
    
    async def stream_chat(self, message: str) -> AsyncIterator[str]:
        """Stream responses for real-time chat."""
        self.conversation_history.append({"role": "user", "content": message})
        
        stream = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": self.system_prompt},
                *self.conversation_history
            ],
            stream=True
        )
        
        full_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                full_response += content
                yield content
        
        self.conversation_history.append({
            "role": "assistant",
            "content": full_response
        })
```

### 2. Base Agent (TypeScript)

```typescript
import OpenAI from 'openai';
import { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources';

export abstract class BaseAgent {
  protected client: OpenAI;
  protected conversationHistory: ChatCompletionMessageParam[] = [];
  
  constructor(
    public readonly agentId: string,

From x1chg956/sdlc-skills, Apache-2.0.

More from x1chg956/sdlc-skills