Quick Start Guide

This guide will help you create a simple multi-agent system with PilottAI.

Creating Your First Agent

Let’s create a simple document processing agent that can extract and analyze text from documents.

import asyncio
from pilottai import Serve
from pilottai.core import AgentConfig, LLMConfig, AgentType

async def main():
    # Configure LLM
    llm_config = LLMConfig(
        model_name="gpt-4",
        provider="openai",
        api_key="your-api-key"  # Replace with your actual API key
    )

    # Initialize PilottAI
    pilott = Serve(name="QuickStart")

    # Start the system
    await pilott.start()

    try:
        # Add a document processing agent
        doc_agent = await pilott.add_agent(
            title="document_processor",
            goal="Process and analyze documents efficiently",
            tools=["text_extractor"],
            llm_config=llm_config
        )

        # Create a simple job
        result = await pilott.execute([{
            "type": "process_text",
            "description": "Summarize the following text",
            "content": "PilottAI is a Python framework for building autonomous multi-agent systems with advanced orchestration capabilities. It provides enterprise-ready features for building scalable AI applications."
        }])

        # Print the result
        print(f"Job result: {result[0].output}")

    finally:
        # Always stop the system properly
        await pilott.stop()

if __name__ == "__main__":
    asyncio.run(main())

Building a Multi-Agent System

Now, let’s create a more complex system with multiple agents that collaborate:

import asyncio
from pilottai import Serve
from pilottai.core import AgentConfig, LLMConfig, AgentType
from pilottai.tools import Tool

async def main():
    # Configure LLM
    llm_config = LLMConfig(
        model_name="gpt-4",
        provider="openai",
        api_key="your-api-key"  # Replace with your actual API key
    )

    # Initialize PilottAI
    pilott = Serve(name="MultiAgentSystem")

    # Start the system
    await pilott.start()

    try:
        # Create custom tools
        search_tool = Tool(
            name="web_search",
            description="Search the web for information",
            function=lambda **kwargs: f"Search results for: {kwargs.get('query')}",
            parameters={"query": "str"}
        )

        analyze_tool = Tool(
            name="text_analyzer",
            description="Analyze text content",
            function=lambda **kwargs: f"Analysis of: {kwargs.get('content')}",
            parameters={"content": "str", "type": "str"}
        )

        # Add a research agent
        research_agent = await pilott.add_agent(
            title="researcher",
            goal="Find and collect relevant information",
            tools=["web_search"],
            llm_config=llm_config
        )

        # Add an analyst agent
        analyst_agent = await pilott.add_agent(
            title="analyst",
            goal="Analyze and synthesize information",
            tools=["text_analyzer"],
            llm_config=llm_config
        )

        # Execute a research job
        research_result = await pilott.execute([{
            "type": "research",
            "description": "Research information about AI orchestration",
            "agent": "researcher"
        }])

        # Execute an analysis job using the research result
        analysis_result = await pilott.execute([{
            "type": "analyze",
            "description": "Analyze the research findings",
            "content": research_result[0].output,
            "agent": "analyst"
        }])

        # Print the final result
        print(f"Research: {research_result[0].output}")
        print(f"Analysis: {analysis_result[0].output}")

    finally:
        # Always stop the system properly
        await pilott.stop()

if __name__ == "__main__":
    asyncio.run(main())

Handling Document Processing

PilottAI excels at document processing jobs. Here’s how to set up a document processing pipeline:

import asyncio
from pilottai import Serve
from pilottai.core import AgentConfig, LLMConfig, AgentType
from pilottai.tools import Tool

async def process_document():
    # Initialize PilottAI
    pilott = Serve(name="DocumentProcessor")

    # Configure LLM
    llm_config = LLMConfig(
        model_name="gpt-4",
        provider="openai",
        api_key="your-api-key"  # Replace with your actual API key
    )

    # Start the system
    await pilott.start()

    try:
        # Add a document processing agent
        doc_processor = await pilott.add_agent(
            title="document_processor",
            goal="Process and analyze documents efficiently",
            tools=["text_extractor", "content_analyzer"],
            llm_config=llm_config
        )

        # Process a document
        result = await pilott.execute([{
            "type": "process_document",
            "description": "Extract key information from the document",
            "file_path": "document.pdf",
            "extract_metadata": True
        }])

        # Print the result
        print(f"Document processing result: {result[0].output}")

    finally:
        # Always stop the system properly
        await pilott.stop()

if __name__ == "__main__":
    asyncio.run(process_document())

Using Orchestration Features

PilottAI provides advanced orchestration capabilities for scaling your agent system:

import asyncio
from pilottai import Serve
from pilottai.core import AgentConfig, LLMConfig
from pilottai.orchestration import DynamicScaling, LoadBalancer

async def main():
    # Initialize PilottAI with orchestration features
    pilott = Serve(name="OrchestrationDemo")

    # Configure LLM
    llm_config = LLMConfig(
        model_name="gpt-4",
        provider="openai",
        api_key="your-api-key"  # Replace with your actual API key
    )

    # Configure dynamic scaling
    scaling_config = {
        "min_agents": 2,
        "max_agents": 5,
        "scale_up_threshold": 0.8,
        "scale_down_threshold": 0.3
    }

    # Configure load balancer
    lb_config = {
        "check_interval": 30,
        "overload_threshold": 0.7
    }

    # Start the system
    await pilott.start()

    try:
        # Enable dynamic scaling
        await pilott.enable_dynamic_scaling(config=scaling_config)

        # Enable load balancing
        await pilott.enable_load_balancing(config=lb_config)

        # Add base worker agents
        for i in range(2):
            await pilott.add_agent(
                title=f"worker_{i}",
                goal="Process jobs efficiently",
                llm_config=llm_config
            )

        # Generate a series of jobs to test scaling
        jobs = []
        for i in range(10):
            jobs.append({
                "type": "process",
                "description": f"Process job {i}",
                "data": f"Sample data {i}"
            })

        # Execute jobs in parallel
        results = await pilott.execute(jobs)

        # Print system metrics after execution
        metrics = pilott.get_metrics()
        print(f"System metrics: {metrics}")

    finally:
        # Always stop the system properly
        await pilott.stop()

if __name__ == "__main__":
    asyncio.run(main())

Next Steps

Now that you’ve created your first PilottAI agents, continue to the Basic Concepts guide to learn more about:

Agent architecture and capabilities
Job routing and execution
Memory systems
Orchestration features
Tool integration

For more advanced examples, check the Examples section.

Getting Started

Core Components

Orchestration

Tools

Contributing

Quickstart

Quick Start Guide

Creating Your First Agent

Building a Multi-Agent System

Handling Document Processing

Using Orchestration Features

Next Steps

​Quick Start Guide

​Creating Your First Agent

​Building a Multi-Agent System

​Handling Document Processing

​Using Orchestration Features

​Next Steps

Quick Start Guide

Creating Your First Agent

Building a Multi-Agent System

Handling Document Processing

Using Orchestration Features

Next Steps