Asktheapi Team Builder
    Asktheapi Team Builder

    Asktheapi Team Builder

    Agent network builder for communicating with openapi apis. Based in autogen

    4.3

    GitHub Stats

    Stars

    1

    Forks

    1

    Release Date

    5/3/2025

    about 2 months ago

    Detailed Description

    AskTheApi Team Builder

    PyPI version License: MIT Python Versions

    A high-level Python library for building and managing networks of autonomous agents that collaborate to solve complex tasks. It's designed to work seamlessly with APIs defined using the OpenAPI standard. The library provides a clean, type-safe interface for creating, configuring, and running teams of agents, making it easy to orchestrate multi-agent workflows with minimal boilerplate.

    Features

    • 🚀 Effortless Agent Network Creation: Quickly build agent networks with custom tools and capabilities based on OpenAPI specifications.

    • 🤝 Team-Based Collaboration: Easily define agent teams with automatic coordination handled by a built-in planning agent.

    • 📡 Streaming Interactions: Stream agent communication in real-time for more dynamic and responsive workflows.

    • 🔧 Built-in HTTP Client: Simplify tool implementation with an integrated HTTP client ready to call external APIs.

    • ✨ Type Safety with Pydantic: Leverage Pydantic models for robust data validation and clear type definitions.

    • 🎯 Clean and Intuitive API: Designed for developers—minimal boilerplate, maximum clarity.

    Installation

    pip install asktheapi-team-builder
    

    Quick Start

    Here's how to use the package:

    1. Create agents from OpenAPI spec

    from asktheapi_team_builder import TeamBuilder, Agent, Tool, Message, APISpecHandler
    from typing import List
    async def create_agents_from_spec():
        # Initialize handlers
        api_spec_handler = APISpecHandler()
    
        # Download and parse OpenAPI spec
        spec_content = await api_spec_handler.download_url_spec("https://api.example.com/openapi.json")
    
        # Classify endpoints into logical groups
        classification_result = await api_spec_handler.classify_spec(
            spec_content
        )
    
        # Generate agents for each group
        agents = []
        for group_spec in classification_result.specs:
            agent_result = await api_spec_handler.generate_agent_for_group(
                group_spec,
                spec_content
            )
            agents.append(agent_result)
    
        return agents
    

    2. Build and run a team

    async def run_agent_team(agents: List[Agent], query: str):
        # Initialize team builder
        team_builder = TeamBuilder(
            model="gpt-4",
            model_config={"temperature": 0.7}
        )
    
        # Build the team
        team = await team_builder.build_team(agents)
    
        # Create messages
        messages = [
            Message(
                role="user",
                content=query
            )
        ]
    
        # Run the team with streaming
        async for event in team_builder.run_team(team, messages, stream=True):
            if isinstance(event, ChatMessage):
                print(f"{event.source}: {event.content}")
    

    Example usage

    async def main():
        # Create agents from spec
        api_agents = await create_agents_from_spec()
    
        # Combine with manual agents
        all_agents = [weather_agent] + api_agents
    
        # Run the team
        await run_agent_team(
            all_agents,
            "What's the weather like in London and how might it affect local businesses?"
        )
    

    Custom Headers and Configuration

    You can configure the team builder with custom headers and model settings:

    team_builder = TeamBuilder(
        model="gpt-4",
        model_config={
            "temperature": 0.7,
            "default_headers": {
                "Authorization": "Bearer your-token",
                "Custom-Header": "custom-value"
            }
        }
    )
    
    # Run team with extra headers for specific requests
    team = await team_builder.build_team(agents)
    result = await team_builder.run_team(
        team,
        messages,
        extra_headers={"Request-ID": "123"}
    )
    

    MCP (Model Context Protocol) Support

    The library includes built-in support for Model Context Protocol, allowing you to expose your agent teams as API endpoints with automatic tool generation from OpenAPI specifications.

    from asktheapi_team_builder import MCPService, MCPConfig
    
    # Configure MCP service
    mcp_config = MCPConfig(
        transport="sse",  # Server-Sent Events transport
        port=8000,        # Port to run the MCP server
        name="asktheapi_mcp"  # Service name
    )
    
    # Initialize MCP service
    mcp_service = MCPService(mcp_config)
    
    # Start MCP server with OpenAPI spec
    await mcp_service.start_from_spec(
        url_spec="https://api.example.com/openapi.json",
        headers={"Authorization": "Bearer your-token"}
    )
    

    The MCP service will:

    • Automatically download and parse the OpenAPI specification
    • Classify endpoints into logical groups
    • Generate appropriate tools for each group
    • Expose these tools through a Model Control Protocol interface
    • Handle real-time streaming of agent interactions

    Contributing

    Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

    1. Fork the repository
    2. Create your feature branch (git checkout -b feature/amazing-feature)
    3. Commit your changes (git commit -m 'Add some amazing feature')
    4. Push to the branch (git push origin feature/amazing-feature)
    5. Open a Pull Request

    Development Setup

    # Clone the repository
    git clone https://github.com/alexalbala/asktheapi-team-builder.git
    cd asktheapi-team-builder
    
    # Install dependencies
    pip install -e ".[dev]"
    
    # Run tests
    pytest
    

    License

    This project is licensed under the MIT License - see the LICENSE file for details.

    Acknowledgments

    • Built on top of Microsoft's AutoGen
    • Inspired by the need for a higher-level interface for agent team management

    About the Project

    This app has not been claimed by its owner yet.

    Claim Ownership

    Receive Updates

    Security Updates

    Get notified about trust rating changes

    to receive email notifications.