Agent Architecture

class AgentType(StrEnum):
    LLM = auto()
    BASIC = auto()
    SMART = auto()
    CUSTOM = auto()
    ORCHESTRATOR = auto()
    PARALLEL = auto()
    EVALUATOR_OPTIMIZER = auto()
    ROUTER = auto()
    CHAIN = auto()
    ITERATIVE_PLANNER = auto()
    MAKER = auto()

@dataclass
class AgentConfig:
    name: str
    instruction: str = DEFAULT_AGENT_INSTRUCTION
    description: str | None = None
    tool_input_schema: dict[str, Any] | None = None
    servers: list[str] = field(default_factory=list)
    tools: dict[str, list[str]] = field(default_factory=dict)
    resources: dict[str, list[str]] = field(default_factory=dict)
    prompts: dict[str, list[str]] = field(default_factory=dict)
    skills: SkillConfig = SKILLS_DEFAULT
    model: str | None = None
    use_history: bool = True
    default_request_params: RequestParams | None = None
    human_input: bool = False
    agent_type: AgentType = AgentType.BASIC
    default: bool = False
    tool_only: bool = False
    function_tools: FunctionToolsConfig = None
    shell: bool = False
    cwd: Path | None = None
    mcp_connect: list[MCPConnectTarget] = field(default_factory=list)

from fast_agent import FastAgent

fast = FastAgent("My App")

@fast.agent(
    name="assistant",
    instruction="You are a helpful AI assistant."
)
async def main():
    async with fast.run() as agent:
        # Agent is initialized and ready
        response = await agent("Hello!")
        print(response)
    # Agent is automatically cleaned up

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

@fast.agent(
    name="calculator",
    instruction="Perform mathematical calculations.",
    servers=["math"]
)

from fast_agent.agents.agent_types import AgentConfig, AgentType
from fast_agent.agents.mcp_agent import McpAgent

config = AgentConfig(
    name="custom_agent",
    instruction="Custom instructions",
    agent_type=AgentType.BASIC,
    servers=["filesystem"],
    use_history=True
)

agent = McpAgent(config=config, context=context)
await agent.initialize()

# Simple string message
response = await agent("What is 2+2?")

# Explicit send method
response = await agent.send("Tell me a joke")

# Start an interactive chat session
await agent.interactive()

# Or with explicit method call
await agent.prompt()

# Attach a resource to the message
response = await agent.with_resource(
    "Summarize this document",
    "resource://server/document.pdf"
)

config = AgentConfig(
    name="file_agent",
    instruction="Help with file operations",
    servers=["filesystem"]  # MCP server name from config
)

# Attach server at runtime
result = await agent.attach_mcp_server(
    server_name="new_server",
    server_config=server_settings
)

# Detach server
result = await agent.detach_mcp_server("server_name")

# List attached servers
servers = agent.list_attached_mcp_servers()

# Tools are automatically available from MCP servers
result = await agent.call_tool(
    name="filesystem__read_file",
    arguments={"path": "/path/to/file.txt"}
)

# Apply a prompt template from an MCP server
response = await agent.apply_prompt(
    "template_name",
    arguments={"variable": "value"}
)

# Get a resource
resource = await agent.get_resource(
    resource_uri="resource://server/path",
    namespace="server_name"
)

# List available resources
resources = await agent.list_resources(namespace="server_name")

@fast.agent(
    name="stateful_agent",
    instruction="Remember our conversation",
    use_history=True  # Maintains history
)

@fast.agent(
    name="stateless_agent",
    instruction="Process each message independently",
    use_history=False  # No history
)

# Clear conversation history
agent.clear(clear_prompts=True)

# Access message history
history = agent.message_history

@fast.agent(
    name="dev_agent",
    instruction="Assist with development tasks",
    shell=True,  # Enable shell access
    cwd=Path("/project")  # Set working directory
)

@fast.agent(
    name="skilled_agent",
    instruction="Use available skills. {{agentSkills}}",
    skills=SKILLS_DEFAULT  # Load default skills
)

@fast.agent(
    name="interactive_agent",
    instruction="Request clarification when needed",
    human_input=True
)