Basic Concepts

This guide introduces the core concepts of the PilottAI framework.

Framework Architecture

PilottAI is designed around a modular, hierarchical architecture:

Core Components

Serve: The main orchestrator that manages agents, routes jobs, and coordinates execution.
Agents: Autonomous entities that perform specific jobs using LLMs and tools.
Jobs: Units of work that are routed to appropriate agents for execution.
Memory: Storage system for context, job history, and knowledge.
Tools: Integrations and capabilities that agents can use to accomplish jobs.
Orchestration: Systems for scaling, load balancing, and fault tolerance.

Agents

Agents are the primary actors in the PilottAI framework. Each agent:

Has a specific title and goal
Can use tools to interact with external systems
Utilizes LLMs for decision-making and job execution
Maintains its own memory and context

Agent Types

PilottAI supports different agent types:

Orchestrator: Manages and delegates jobs to worker agents
Worker: Executes specific jobs using specialized capabilities
Hybrid: Combines orchestration and execution capabilities

Agent Configuration

Agents are configured using the AgentConfig class:

from pilottai.core import AgentConfig, AgentType

config = AgentConfig(
    title="document_processor",          # Agent's title/type
    agent_type=AgentType.WORKER,         # Agent classification
    goal="Process documents efficiently", # Main objective
    description="Document processing worker", # Brief description
    backstory=None,                      # Optional background story
    knowledge_sources=[],                # Available knowledge sources
    tools=["text_extractor"],            # Available tools
    required_capabilities=[],            # Required capabilities
    max_iterations=20,                   # Maximum execution iterations
    max_rpm=None,                        # Rate limits
    memory_enabled=True,                 # Enable memory
    verbose=False                        # Verbose logging
)

Jobs

Jobs represent units of work that agents perform. Each job:

Has a description and context
May be assigned to a specific agent or automatically routed
Has a priority level
Tracks execution status and results

Job Lifecycle

Job Creation

from pilottai.core import Job, JobPriority

job = Job(
    description="Extract key information from document",
    priority=JobPriority.HIGH,
    context={"file_path": "document.pdf"}
)

Memory System

PilottAI includes a sophisticated memory system that:

Stores job execution history
Maintains agent context
Enables semantic search and retrieval
Supports knowledge persistence

Memory Components

Job Memory: Records job execution details
Semantic Memory: Stores knowledge and context
Enhanced Memory: Advanced memory with pattern recognition

Using Memory

# Store information in semantic memory
await agent.memory.store_semantic(
    text="Important information about topic X",
    metadata={"topic": "X", "importance": "high"},
    tags={"research", "topic_x"}
)

# Search memory
results = await agent.memory.search(
    query="topic X",
    tags={"research"}
)

LLM Integration

PilottAI uses Large Language Models for agent intelligence. Key concepts:

LLM Configuration: Settings for model, provider, and parameters
LLM Handler: Manages LLM interactions with proper error handling
Function Calling: Structured LLM output for tool use

LLM Configuration

from pilottai.core import LLMConfig

llm_config = LLMConfig(
    model_name="gpt-4",
    provider="openai",
    api_key="your-api-key",
    temperature=0.7,
    max_tokens=2000
)

Tools

Tools extend agent capabilities by providing:

External system integrations
Specialized functionality
Job-specific utilities

Tool Creation

from pilottai.tools import Tool

email_tool = Tool(
    name="email_sender",
    description="Send emails to recipients",
    function=lambda **kwargs: send_email(**kwargs),
    parameters={
        "to": "str",
        "subject": "str",
        "body": "str"
    }
)

Orchestration

PilottAI includes advanced orchestration features:

Dynamic Scaling

Automatically adjusts the number of agents based on system load:

await pilott.enable_dynamic_scaling(
    config={
        "min_agents": 2,
        "max_agents": 10,
        "scale_up_threshold": 0.8,
        "scale_down_threshold": 0.3
    }
)

Load Balancing

Distributes jobs across agents to optimize performance:

await pilott.enable_load_balancing(
    config={
        "check_interval": 30,
        "overload_threshold": 0.7
    }
)

Fault Tolerance

Handles agent failures and ensures system reliability:

await pilott.enable_fault_tolerance(
    config={
        "health_check_interval": 30,
        "max_recovery_attempts": 3
    }
)

Next Steps

Now that you understand the basic concepts of PilottAI, you can:

Explore specialized Agents
Learn about Memory Systems
Dive into Orchestration features
See Examples of PilottAI in action

Getting Started

Core Components

Orchestration

Tools

Contributing

Concepts

Basic Concepts

Framework Architecture

Core Components

Agents

Agent Types

Agent Configuration

Jobs

Job Lifecycle

Job Creation

Memory System

Memory Components

Using Memory

LLM Integration

LLM Configuration

Tools

Tool Creation

Orchestration

Dynamic Scaling

Load Balancing

Fault Tolerance

Next Steps

​Basic Concepts

​Framework Architecture

​Core Components

​Agents

​Agent Types

​Agent Configuration

​Jobs

​Job Lifecycle

​Job Creation

​Memory System

​Memory Components

​Using Memory

​LLM Integration

​LLM Configuration

​Tools

​Tool Creation

​Orchestration

​Dynamic Scaling

​Load Balancing

​Fault Tolerance

​Next Steps

Basic Concepts

Framework Architecture

Core Components

Agents

Agent Types

Agent Configuration

Jobs

Job Lifecycle

Job Creation

Memory System

Memory Components

Using Memory

LLM Integration

LLM Configuration

Tools

Tool Creation

Orchestration

Dynamic Scaling

Load Balancing

Fault Tolerance

Next Steps