Agent Configuration Examples¶

Practical examples for using agent configurations in various scenarios.

Table of Contents¶

Basic Examples
Advanced Examples
Integration Examples
Real-World Use Cases

Basic Examples¶

Example 1: Simple Chat Agent¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno import AgnoAgentFactory, AgnoMongoDBResources, AgnoModelResources

# Initialize resources
cat_name = "myapp"
storage_resources = AgnoMongoDBResources(cat_name)
model_resources = AgnoModelResources(cat_name)
factory = AgnoAgentFactory(cat_name)

# Get storage and model
agent_storage = storage_resources.get_agent_storage("chat_agent")
agent_model = model_resources.get_open_ai_chat("gpt-4o-mini")

# Create agent
agent = factory.create_openai_chat_agent(
    name="chat_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=basic_agent_config
)

# Use agent
response = agent.run(
    input="Hello, how are you?",
    user_id="user123",
    session_id="session1",
    stream=False
)

Example 2: Minimal Agent (No Memory, No History)¶

from bast_ai_agno.dto.agent_configs import minimal_agent_config

agent = factory.create_openai_chat_agent(
    name="minimal_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=minimal_agent_config
)

Example 3: Verbose Agent with Long History¶

from bast_ai_agno.dto.agent_configs import verbose_agent_config

agent = factory.create_openai_chat_agent(
    name="verbose_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=verbose_agent_config
)

Example 10: Greeting Agent¶

from bast_ai_agno.dto.agent_configs import greeting_agent_config

# Create greeting agent
agent = factory.create_openai_chat_agent(
    name="greeting_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=greeting_agent_config
)

# Use agent - responds with friendly greetings
response = agent.run(
    input="Hello",
    user_id="user123",
    session_id="session1"
)

Example 11: End Conversation Agent¶

from bast_ai_agno.dto.agent_configs import end_conversation_agent_config

# Create end conversation agent
agent = factory.create_openai_chat_agent(
    name="end_conversation_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=end_conversation_agent_config
)

# Use agent - responds with polite closing messages
response = agent.run(
    input="Goodbye",
    user_id="user123",
    session_id="session1"
)

Example 12: Early Exit Agent with Structured Output¶

from bast_ai_agno.dto.agent_configs import early_exit_agent_config, EarlyExitDecision

# Create early exit agent (includes output_schema by default)
agent = factory.create_openai_chat_agent(
    name="early_exit_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=early_exit_agent_config
)

# Use agent - returns structured decision
response = agent.run(
    input="Thank you, I'm all set!",
    user_id="user123",
    session_id="session1"
)

# Get structured output
decision: EarlyExitDecision = response.content
print(f"Action: {decision.action}")  # e.g., "HARD_EXIT"
print(f"Reason: {decision.reason}")  # e.g., "HAS_ENDING_PHRASE"

# Use in decision logic
if decision.action == "HARD_EXIT":
    print("Must exit the conversation")
elif decision.action == "SOFT_EXIT":
    print("Caller can decide whether to exit")
else:  # KEEP_GOING
    print("Continue the conversation")

Advanced Examples¶

Example 4: RAG Agent with Knowledge Base¶

from bast_ai_agno.dto.agent_configs import knowledge_agent_config
from bast_ai_agno import AgnoKnowledgeResources

# Initialize knowledge resources
kb_resources = AgnoKnowledgeResources(cat_name)
agent_knowledge = kb_resources.get_knowledge("my_knowledge_base")

# Create RAG agent
agent = factory.create_openai_chat_agent(
    name="rag_agent",
    model=agent_model,
    db=agent_storage,
    knowledge=agent_knowledge,
    config_raw=knowledge_agent_config
)

# Agent will automatically search knowledge base
response = agent.run(
    input="What are the side effects of medication X?",
    user_id="user123",
    session_id="session1"
)

Example 5: Tool-Enabled Agent¶

from bast_ai_agno.dto.agent_configs import tool_enabled_agent_config
from bast_ai_agno.dto.agent_tool_utils import add_tools_to_config
from agno.tools.duckduckgo import DuckDuckGoTools

# Add tools to config
config = add_tools_to_config(
    tool_enabled_agent_config,
    [DuckDuckGoTools(modifier="site:example.com")]
)

# Create tool-enabled agent
agent = factory.create_openai_chat_agent(
    name="tool_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

# Agent can use tools
response = agent.run(
    input="Search for the latest news about AI",
    user_id="user123",
    session_id="session1"
)

Example 6: Reasoning Agent¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno.dto.agent_reasoning_utils import build_reasoning_config

# Add reasoning to config
config = build_reasoning_config(
    basic_agent_config,
    min_steps=2,
    max_steps=15
)

# Create reasoning agent
agent = factory.create_openai_chat_agent(
    name="reasoning_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

# Agent will think through problems
response = agent.run(
    input="Solve this complex problem step by step...",
    user_id="user123",
    session_id="session1"
)

Example 7: Memory-Enabled Agent¶

from bast_ai_agno.dto.agent_configs import memory_agent_config
from bast_ai_agno import AgnoMemoryResources

# Initialize memory resources
memory_resources = AgnoMemoryResources(cat_name)
memory_model = model_resources.get_open_ai_chat("gpt-4o-mini")

# Create memory manager
memory_manager = memory_resources.get_memory_manager(
    model=memory_model,
    db=agent_storage
)

# Create memory-enabled agent
agent = factory.create_openai_chat_agent(
    name="memory_agent",
    model=agent_model,
    db=agent_storage,
    memory_manager=memory_manager,
    config_raw=memory_agent_config
)

# Agent remembers across conversations
response = agent.run(
    input="I prefer dark mode interfaces",
    user_id="user123",
    session_id="session1"
)

# Later, agent remembers
response = agent.run(
    input="What are my preferences?",
    user_id="user123",
    session_id="session2"
)

Example 8: Session-Aware Agent¶

from bast_ai_agno.dto.agent_configs import session_aware_agent_config

agent = factory.create_openai_chat_agent(
    name="session_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=session_aware_agent_config
)

# Agent maintains context across sessions
response = agent.run(
    input="Hello, I'm starting a new session",
    user_id="user123",
    session_id="session1"
)

# Agent can search previous sessions
response = agent.run(
    input="What did we discuss last time?",
    user_id="user123",
    session_id="session2"
)

Example 9: Context-Enhanced Agent¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno.dto.agent_context_utils import build_context_enhanced_config

# Add context engineering
config = build_context_enhanced_config(
    basic_agent_config,
    add_name=True,
    add_datetime=True,
    add_location=True,
    timezone="America/New_York"
)

agent = factory.create_openai_chat_agent(
    name="context_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

# Agent is aware of time, location, and identity
response = agent.run(
    input="What time is it?",
    user_id="user123",
    session_id="session1"
)

Example 10: Guarded Agent with Safety¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno.dto.agent_guardrails_utils import build_guarded_config

# Define guardrail
def content_guardrail(agent, input_text, **kwargs):
    """Block inappropriate content"""
    blocked_words = ["spam", "hack"]
    if any(word in input_text.lower() for word in blocked_words):
        raise ValueError("Content blocked: inappropriate content detected")
    return input_text

# Add guardrails
config = build_guarded_config(
    basic_agent_config,
    guardrails=[content_guardrail]
)

agent = factory.create_openai_chat_agent(
    name="guarded_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

Integration Examples¶

Example 11: Combining Multiple Features¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno.dto.agent_reasoning_utils import build_reasoning_config
from bast_ai_agno.dto.agent_tool_utils import add_tools_to_config
from bast_ai_agno.dto.agent_session_utils import build_session_config
from bast_ai_agno.dto.agent_validation_utils import validate_agent_config
from agno.tools.duckduckgo import DuckDuckGoTools

# Build complex config step by step
config = basic_agent_config.copy()
config = build_reasoning_config(config, min_steps=2, max_steps=10)
config = add_tools_to_config(config, [DuckDuckGoTools()])
config = build_session_config(config, cache=True, num_sessions=5)

# Validate before use
is_valid, errors = validate_agent_config(config)
if not is_valid:
    raise ValueError(f"Config errors: {errors}")

# Create agent
agent = factory.create_openai_chat_agent(
    name="complex_agent",
    model=agent_model,
    db=agent_storage,
    knowledge=agent_knowledge,
    config_raw=config
)

Example 12: Using Presets¶

from bast_ai_agno.dto.agent_preset_utils import create_rag_agent_config
from bast_ai_agno.dto.agent_preset_utils import create_conversational_agent_config

# Create RAG agent preset
rag_config = create_rag_agent_config(
    knowledge_base_name="medical_kb",
    search_knowledge=True,
    enable_memory=True
)

# Create conversational agent preset
conv_config = create_conversational_agent_config(
    enable_memory=True,
    num_history_runs=15,
    enable_session_summaries=True
)

Example 13: Merging Configurations¶

from bast_ai_agno.dto.agent_configs import basic_agent_config, memory_agent_config
from bast_ai_agno.dto.agent_merge_utils import merge_configs

# Merge base with memory config
merged_config = merge_configs(
    basic_agent_config,
    memory_agent_config,
    strategy="override"  # Later configs override earlier ones
)

# Or preserve base settings
preserved_config = merge_configs(
    basic_agent_config,
    memory_agent_config,
    strategy="preserve"  # Earlier configs take precedence
)

Real-World Use Cases¶

Use Case 1: Medical Assistant with RAG¶

from bast_ai_agno.dto.agent_configs import rxdemo_agent_config
from bast_ai_agno.dto.agent_tool_utils import add_tools_to_config
from agno.tools.duckduckgo import DuckDuckGoTools

# Medical assistant configuration
config = add_tools_to_config(
    rxdemo_agent_config,
    [DuckDuckGoTools(modifier="site:dailymed.nlm.nih.gov")]
)

agent = factory.create_openai_chat_agent(
    name="medical_assistant",
    model=agent_model,
    db=agent_storage,
    knowledge=agent_knowledge,
    config_raw=config
)

# Use for medication queries
response = agent.run(
    input="What are the side effects of aspirin?",
    user_id="patient123",
    session_id="consultation1"
)

Use Case 2: Research Assistant with Tools and Reasoning¶

from bast_ai_agno.dto.agent_configs import tool_enabled_agent_config
from bast_ai_agno.dto.agent_reasoning_utils import build_reasoning_config
from bast_ai_agno.dto.agent_tool_utils import add_tools_to_config
from agno.tools.duckduckgo import DuckDuckGoTools

# Build research assistant config
config = tool_enabled_agent_config.copy()
config = build_reasoning_config(config, min_steps=3, max_steps=15)
config = add_tools_to_config(config, [DuckDuckGoTools()])

agent = factory.create_openai_chat_agent(
    name="research_assistant",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

# Use for research tasks
response = agent.run(
    input="Research the latest developments in quantum computing",
    user_id="researcher123",
    session_id="research1"
)

Use Case 3: Customer Support with Memory and Sessions¶

from bast_ai_agno.dto.agent_configs import session_aware_agent_config
from bast_ai_agno import AgnoMemoryResources

# Setup memory
memory_resources = AgnoMemoryResources(cat_name)
memory_manager = memory_resources.get_memory_manager(
    model=memory_model,
    db=agent_storage
)

agent = factory.create_openai_chat_agent(
    name="support_agent",
    model=agent_model,
    db=agent_storage,
    memory_manager=memory_manager,
    config_raw=session_aware_agent_config
)

# Remember customer preferences across sessions
response = agent.run(
    input="I prefer email notifications",
    user_id="customer123",
    session_id="support_ticket_1"
)

# Later, agent remembers
response = agent.run(
    input="What are my notification preferences?",
    user_id="customer123",
    session_id="support_ticket_2"
)

Use Case 4: Analytics Agent with Structured Output¶

from bast_ai_agno.dto.agent_configs import basic_agent_config
from bast_ai_agno.dto.agent_tool_utils import add_output_schema_to_config
from pydantic import BaseModel, Field
from typing import List

class AnalyticsResult(BaseModel):
    summary: str = Field(description="Analysis summary")
    metrics: List[str] = Field(description="Key metrics identified")
    insights: List[str] = Field(description="Insights from the data")

# Add structured output
config = add_output_schema_to_config(
    basic_agent_config,
    AnalyticsResult
)

agent = factory.create_openai_chat_agent(
    name="analytics_agent",
    model=agent_model,
    db=agent_storage,
    config_raw=config
)

# Get structured response
response = agent.run(
    input="Analyze this sales data: ...",
    user_id="analyst123",
    session_id="analysis1"
)

# Response is automatically validated as AnalyticsResult
result: AnalyticsResult = response.content

Use Case 5: Multi-Agent Orchestration¶

from bast_ai_agno.dto.agent_configs import dependency_heavy_agent_config

# Create specialized agents
researcher = factory.create_openai_chat_agent(
    name="researcher",
    model=agent_model,
    db=agent_storage,
    config_raw=tool_enabled_agent_config
)

writer = factory.create_openai_chat_agent(
    name="writer",
    model=agent_model,
    db=agent_storage,
    config_raw=verbose_agent_config
)

# Create orchestrator agent with dependencies
orchestrator_config = dependency_heavy_agent_config.copy()
orchestrator_config["dependencies"] = [researcher, writer]

orchestrator = factory.create_openai_chat_agent(
    name="orchestrator",
    model=agent_model,
    db=agent_storage,
    config_raw=orchestrator_config
)

# Orchestrator can delegate to dependencies
response = orchestrator.run(
    input="Research and write about quantum computing",
    user_id="user123",
    session_id="session1"
)

Best Practices¶

1. Validate Before Use¶

from bast_ai_agno.dto.agent_validation_utils import validate_agent_config

is_valid, errors = validate_agent_config(config)
if not is_valid:
    print(f"Configuration errors: {errors}")
    # Fix errors before proceeding

2. Use Builders for Complex Configs¶

# Instead of manually setting all fields
config = {
    "reasoning": True,
    "reasoning_min_steps": 2,
    "reasoning_max_steps": 10,
    # ... many more fields
}

# Use builders
from bast_ai_agno.dto.agent_reasoning_utils import build_reasoning_config
config = build_reasoning_config(base_config, min_steps=2, max_steps=10)

3. Use Presets for Common Patterns¶

# Instead of manually configuring RAG
# Use preset
from bast_ai_agno.dto.agent_preset_utils import create_rag_agent_config
rag_config = create_rag_agent_config(knowledge_base_name="my_kb")

4. Combine Features Incrementally¶

# Start simple
config = basic_agent_config.copy()

# Add features as needed
if need_reasoning:
    config = build_reasoning_config(config)
if need_tools:
    config = add_tools_to_config(config, tools)
if need_guardrails:
    config = build_guarded_config(config, guardrails=guardrails)

Agent Configuration Examples¶

Table of Contents¶

Basic Examples¶

Example 1: Simple Chat Agent¶

Example 2: Minimal Agent (No Memory, No History)¶

Example 3: Verbose Agent with Long History¶

Example 10: Greeting Agent¶

Example 11: End Conversation Agent¶

Example 12: Early Exit Agent with Structured Output¶

Advanced Examples¶

Example 4: RAG Agent with Knowledge Base¶

Example 5: Tool-Enabled Agent¶

Example 6: Reasoning Agent¶

Example 7: Memory-Enabled Agent¶

Example 8: Session-Aware Agent¶

Example 9: Context-Enhanced Agent¶

Example 10: Guarded Agent with Safety¶

Integration Examples¶

Example 11: Combining Multiple Features¶

Example 12: Using Presets¶

Example 13: Merging Configurations¶

Real-World Use Cases¶

Use Case 1: Medical Assistant with RAG¶

Use Case 2: Research Assistant with Tools and Reasoning¶

Use Case 3: Customer Support with Memory and Sessions¶

Use Case 4: Analytics Agent with Structured Output¶

Use Case 5: Multi-Agent Orchestration¶

Best Practices¶

1. Validate Before Use¶

2. Use Builders for Complex Configs¶

3. Use Presets for Common Patterns¶

4. Combine Features Incrementally¶

Additional Resources¶