Implement AI base agent model framework for building and designing AI applications

[Copilot]

Overview

This PR implements a comprehensive AI base agent model framework that provides the foundation for building and designing any AI application. The framework offers an extensible architecture with pre-built agents, model abstraction, and complete documentation.

What's Included

Core Framework Components

Base Architecture

• BaseAgent: Abstract base class for all agents with configuration management, history tracking, and lifecycle management
• AIModel: Provider-agnostic interface for integrating any AI model or API
• AgentConfig & ModelConfig: Type-safe configuration using Pydantic models

Pre-built Agent Implementations

1. ChatAgent - Conversational AI with:

   • Context-aware conversation management
   • System prompts for behavior customization
   • Full conversation history tracking
   • Role-based message handling (system, user, assistant)

2. TaskAgent - Specialized task execution for:

   • Text summarization
   • Data extraction
   • Content classification
   • Custom task types with extensible prompt templates

3. DesignAgent - AI application design and architecture:

   • Application architecture design
   • Agent workflow creation
   • Multi-agent system planning
   • Design storage and retrieval

Features

• 🔌 Model Agnostic: Easy integration with any AI provider (OpenAI, Anthropic, custom APIs)
• ⚙️ Configuration Management: YAML/JSON support with type validation
• 📊 History Tracking: Built-in tracking for debugging and analysis
• 🎯 Type Safety: Full typing support with Pydantic validation
• 🧪 Mock Model: Included for testing and development
• 📝 Extensible: Create custom agents by inheriting from BaseAgent

Quick Start Example

from sample_ai import ChatAgent, TaskAgent, DesignAgent
from sample_ai.core.agent import AgentConfig

# Create a chat agent
config = AgentConfig(
    name="Assistant",
    description="Helpful AI assistant",
    system_prompt="You are a helpful AI assistant.",
    temperature=0.7
)
agent = ChatAgent(config)
response = agent.process("Hello! How can I help?")

# Execute tasks
task_agent = TaskAgent(config)
summary = task_agent.execute_summarization("Your long text here...")

# Design AI architectures
design_agent = DesignAgent(config)
design = design_agent.design_architecture({
    "name": "my_app",
    "purpose": "Customer support",
    "features": ["chat", "ticketing", "analytics"]
})

Documentation

Comprehensive documentation included:

• README.md - Main documentation with features and installation
• QUICKSTART.md - 5-minute quick start guide
• docs/GETTING_STARTED.md - Comprehensive tutorial
• docs/ARCHITECTURE.md - Framework design and principles
• docs/API_REFERENCE.md - Complete API documentation
• docs/USE_CASES.md - 12 practical real-world examples
• CONTRIBUTING.md - Guidelines for contributors

Examples

Four working examples demonstrate the framework:

• examples/chat_example.py - Conversational AI demonstration
• examples/task_example.py - Task execution showcase
• examples/design_example.py - Architecture design examples
• examples/custom_agent_example.py - Creating custom agents

All examples are tested and working with the included MockModel.

Testing & Quality

• ✅ Unit tests for all agent implementations
• ✅ All examples verified and working
• ✅ Package installation tested
• ✅ Security scan: 0 vulnerabilities (CodeQL)
• ✅ Type safety with Pydantic validation

Installation

git clone https://github.com/vilaswasnik/sample.ai.git
cd sample.ai
pip install -e .

Use Cases

The framework supports building:

• Customer support chatbots
• Content summarization services
• Data extraction pipelines
• Classification systems
• AI architecture design tools
• Multi-agent research assistants
• Code review systems
• Email automation
• Learning management systems
• Content generation pipelines
• And more...

Technical Details

Package Structure:

• 19 Python files (1,209 lines of code)
• 3 agent implementations
• 1 base class, 1 model interface
• Minimal dependencies (pydantic, pyyaml, typing-extensions)
• MIT licensed

Dependencies:

pydantic>=2.0.0
pyyaml>=6.0
typing-extensions>=4.5.0

Extensibility

Create custom agents easily:

from sample_ai.core.agent import BaseAgent, AgentConfig

class MyCustomAgent(BaseAgent):
    def process(self, input_data, **kwargs):
        # Your custom logic
        result = f"Processed: {input_data}"
        self.add_to_history({"input": input_data, "result": result})
        return result

Integrate any AI model:

from sample_ai.core.model import AIModel, ModelConfig

class MyCustomModel(AIModel):
    def generate(self, prompt: str, **kwargs) -> str:
        # Call your AI API
        return response
    
    def chat(self, messages: List[Dict[str, str]], **kwargs) -> str:
        # Chat implementation
        return response

What's Next

This framework provides the foundation for building AI applications. Next steps could include:

• Integration with popular AI APIs (OpenAI, Anthropic, etc.)
• Multi-agent orchestration system
• Built-in prompt templates library
• Vector database integration
• Performance monitoring and logging
• Web UI for agent management

---

This implementation provides a production-ready, extensible framework for building any AI application with a clean, well-documented API and comprehensive examples.

Original prompt

an ai base agent model to build and build and design any ai app.

---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.