Chain-of-Thought Reasoning

from agno.agent import Agent
from agno.models.openai import OpenAIChat

# This model doesn't have native reasoning
# Agno will use Chain-of-Thought automatically
agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    reasoning=True,
    reasoning_min_steps=2,
    reasoning_max_steps=8,
)

from agno.reasoning.step import NextAction

class NextAction(str, Enum):
    CONTINUE = "continue"          # Continue reasoning
    VALIDATE = "validate"          # Validate current result
    FINAL_ANSWER = "final_answer"  # Provide final answer
    RESET = "reset"                # Start over

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    reasoning=True,
    reasoning_min_steps=3,    # Require at least 3 steps
    reasoning_max_steps=15,   # Allow up to 15 steps
)

from agno.agent import Agent
from agno.reasoning.step import ReasoningSteps

# Create a custom reasoning agent
reasoning_agent = Agent(
    name="Custom Reasoner",
    model=OpenAIChat(id="gpt-4"),
    output_schema=ReasoningSteps,  # Must output ReasoningSteps
    instructions="""
    You are a reasoning agent. Break down problems into clear steps.
    Each step should have:
    - title: Brief description
    - action: What you will do
    - result: What you discovered
    - reasoning: Your thought process
    - next_action: continue, validate, or final_answer
    
    Be thorough but concise. Validate your work.
    """,
)

# Use the custom reasoning agent
main_agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    reasoning=True,
    reasoning_agent=reasoning_agent,
)

# Use a faster/cheaper model for main responses
# and a more powerful model for reasoning
agent = Agent(
    model=OpenAIChat(id="gpt-4"),           # Main model
    reasoning=True,
    reasoning_model=OpenAIChat(id="o1"),   # Reasoning model
)

from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    reasoning=True,
    reasoning_min_steps=3,
    reasoning_max_steps=10,
)

response = agent.run(
    "A train leaves Station A at 60 mph. Another train leaves Station B "
    "(100 miles away) at 40 mph heading toward Station A. When do they meet?",
    show_full_reasoning=True,
)

# Output shows reasoning steps:
# Step 1: Define variables and setup
# Step 2: Calculate combined speed
# Step 3: Calculate time to meet
# Step 4: Verify the answer
# Final Answer: They meet in 1 hour

from agno.tools import tool

@tool
def search_documentation(query: str) -> str:
    """Search the documentation database.
    
    Args:
        query: Search query
    
    Returns:
        Relevant documentation
    """
    # Implementation
    return results

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    reasoning=True,
    tools=[search_documentation],
    reasoning_max_steps=8,
)

agent.print_response(
    "How do I configure database connection pooling?",
    show_full_reasoning=True,
)

# Reasoning steps might include:
# 1. Search documentation for "connection pooling"
# 2. Analyze the search results
# 3. Identify configuration parameters
# 4. Provide structured answer

response = agent.run("Complex question", stream=False)

# Access reasoning steps
if response.reasoning_messages:
    for msg in response.reasoning_messages:
        print(f"Role: {msg.role}")
        print(f"Content: {msg.content}")

# Or from metrics
if response.metrics and response.metrics.reasoning_steps:
    for step in response.metrics.reasoning_steps:
        print(f"\nStep: {step.title}")
        print(f"Action: {step.action}")
        print(f"Result: {step.result}")
        print(f"Confidence: {step.confidence}")

from agno.agent import AgentEvent

for event in agent.run("Question", stream=True):
    if event.event_type == AgentEvent.reasoning_step:
        step = event.reasoning_step
        print(f"\n{'='*50}")
        print(f"Step: {step.title}")
        print(f"Action: {step.action}")
        print(f"Result: {step.result}")
        print(f"Next: {step.next_action}")
    
    elif event.event_type == AgentEvent.content_delta:
        print(event.content, end="", flush=True)

from agno.reasoning.step import ReasoningSteps, ReasoningStep

class ReasoningSteps(BaseModel):
    reasoning_steps: List[ReasoningStep]

class ReasoningStep(BaseModel):
    title: Optional[str]        # "Analyze the problem"
    action: Optional[str]       # "I will identify variables"
    result: Optional[str]       # "Found 3 variables: x, y, z"
    reasoning: Optional[str]    # "I need to..."
    next_action: Optional[NextAction]  # continue | final_answer
    confidence: Optional[float] # 0.95