Agent Components Deep Dive

# Example: Structured Prompting with CoT

prompt_template = """
## ROLE
You are a senior data analyst specializing in customer behavior analysis.

## CONTEXT
{retrieved_customer_data}

## TASK
Analyze the customer data above and identify the top 3 factors 
driving churn for the enterprise segment.

## REASONING APPROACH
Use Chain-of-Thought reasoning:
1. First, examine patterns in the data
2. Identify correlations between factors and churn
3. Rank factors by impact strength
4. Explain your reasoning for each factor

## OUTPUT FORMAT
Return a JSON object with this structure:
{{
  "top_factors": [
    {{
      "factor": "factor name",
      "impact_score": 0-100,
      "reasoning": "explanation"
    }}
  ]
}}

## CONSTRAINTS
- Focus only on enterprise segment (>100 employees)
- Use statistical significance (p < 0.05) as threshold
- Do not include speculative factors without data support
"""

result = llm.complete(prompt_template.format(
    retrieved_customer_data=data
))

# Example: Agent with Tool Integration

class CustomerSupportAgent:
    def __init__(self):
        self.tools = {
            "search_knowledge_base": self.search_kb,
            "get_customer_history": self.get_history,
            "create_ticket": self.create_ticket,
            "send_email": self.send_email
        }
    
    def search_kb(self, query):
        # RAG: Search internal knowledge base
        results = vector_db.search(query, top_k=3)
        return results
    
    def get_history(self, customer_id):
        # Database: Fetch customer interaction history
        history = db.query(
            "SELECT * FROM interactions WHERE customer_id = ?",
            customer_id
        )
        return history
    
    def run(self, customer_query, customer_id):
        # Agent decides which tools to use via ReAct pattern
        context = self.get_history(customer_id)
        kb_results = self.search_kb(customer_query)
        
        response = self.generate_response(
            query=customer_query,
            context=context,
            knowledge=kb_results
        )
        
        return response

# Example: Flexible Interaction Interface

class AgentInterface:
    def __init__(self, agent):
        self.agent = agent
    
    # Synchronous text interaction
    def chat(self, message: str) -> str:
        response = self.agent.run(message)
        return response.text
    
    # Synchronous structured interaction
    def api_call(self, request: dict) -> dict:
        response = self.agent.run(request)
        return response.to_json()
    
    # Asynchronous processing
    async def process_batch(self, items: list) -> str:
        job_id = create_job()
        for item in items:
            await self.agent.run_async(item)
        return job_id
    
    # Streaming response
    def stream_response(self, message: str):
        for chunk in self.agent.run_stream(message):
            yield chunk.text
    
    # Inter-agent communication
    def delegate_to_agent(self, task: dict, target_agent):
        result = target_agent.execute(task)
        return result