작동하는 AI 에이전트 구축: 아키텍처와 자동화

result = enrich_lead(lead_id=12345)
# Returns: {'revenue': '$10M', 'industry': 'SaaS', 'employees': 150}

tools = [
    {
        "name": "enrich_lead",
        "description": "Get additional company data about a lead (revenue, employees, industry)",
        "parameters": {
            "lead_id": {"type": "string", "description": "Unique identifier of the lead"}
        }
    },
    {
        "name": "score_lead",
        "description": "Score a lead on a scale of 0-100 based on fit criteria",
        "parameters": {
            "lead_data": {"type": "object", "description": "Lead information including revenue, industry, etc."}
        }
    }
]

{
  "thought": "I need to enrich this lead to get revenue data",
  "action": "enrich_lead",
  "action_input": {"lead_id": "12345"}
}

def execute_tool(tool_name, tool_input):
    try:
        if tool_name == "enrich_lead":
            result = crm_api.enrich(tool_input['lead_id'])
            return {"status": "success", "data": result}
    except Exception as e:
        return {"status": "error", "message": str(e)}

def customer_service_agent(question):
    # 1. Search knowledge base
    articles = search_kb(question)
    
    # 2. LLM picks best article
    response = llm.complete(f"""
        Question: {question}
        Relevant articles: {articles}
        Provide an answer based on these articles.
    """)
    
    # 3. Return response
    return response

def lead_qualification_agent(lead_id):
    lead = crm.get_lead(lead_id)
    
    # Step 1: Enrich
    enriched = enrich_lead(lead)
    
    # Step 2: Score
    score = score_lead(enriched)
    
    # Step 3: Assign
    best_rep = find_best_sales_rep(score)
    crm.assign_lead(lead_id, best_rep)
    
    # Step 4: Notify
    send_slack(f"New qualified lead assigned to {best_rep}")
    
    return {"lead_id": lead_id, "score": score, "assigned_to": best_rep}

def recommendation_agent(user_id):
    # Get user history
    history = db.get_user_history(user_id)
    
    # LLM recommends based on patterns
    recommendation = llm.complete(f"""
        User history: {history}
        Based on past preferences, what should we recommend?
    """)
    
    # Show recommendation, collect feedback
    feedback = user_feedback  # thumbs up/down
    
    # Store feedback for future recommendations
    db.log_feedback(user_id, recommendation, feedback)
    
    return recommendation

def content_pipeline_agent(topic):
    # Supervisor delegates
    research = research_agent(topic)
    draft = writer_agent(research)
    edited = editor_agent(draft)
    published = publisher_agent(edited)
    
    return {"topic": topic, "status": "published"}

from crewai import Agent, Task, Crew

# Define agents
enrichment_agent = Agent(
    role="Data Enrichment Specialist",
    goal="Enrich lead data with company information",
    tools=[enrich_tool]
)

scoring_agent = Agent(
    role="Lead Scoring Expert",
    goal="Score leads based on fit criteria",
    tools=[score_tool]
)

assignment_agent = Agent(
    role="Sales Manager",
    goal="Assign leads to best sales rep",
    tools=[assign_tool, notify_tool]
)

# Define tasks
enrich_task = Task(
    description="Enrich this lead: {lead_id}",
    agent=enrichment_agent
)

score_task = Task(
    description="Score the enriched lead",
    agent=scoring_agent
)

assign_task = Task(
    description="Assign lead to best rep and notify",
    agent=assignment_agent
)

# Run crew
crew = Crew(agents=[enrichment_agent, scoring_agent, assignment_agent],
            tasks=[enrich_task, score_task, assign_task])
result = crew.kickoff(inputs={"lead_id": "12345"})

def test_enrichment_tool():
    result = enrich_tool("lead_123")
    assert result['revenue'] is not None
    assert result['employees'] is not None

def test_scoring_agent():
    lead = {"company": "Acme", "revenue": "10M", "employees": 50}
    score = score_agent(lead)
    assert 0 <= score <= 100

def test_full_loop():
    result = lead_qualification_agent("lead_123")
    assert result['assigned_to'] is not None
    assert result['score'] > 0

def lead_qualification_agent(lead_id):
    """
    Autonomous agent that qualifies leads.
    1. Fetches lead from CRM
    2. Enriches with company data
    3. Scores based on fit criteria
    4. Assigns to best sales rep
    5. Notifies rep
    """

tools = {
    "get_lead": crm.get_lead,
    "enrich_lead": enrichment_api.enrich,
    "score_lead": scoring_model.score,
    "find_best_rep": crm.find_available_rep,
    "assign_lead": crm.assign,
    "send_notification": slack.send
}

# Step 1: Observe
lead = get_lead(lead_id)
print(f"Observing lead: {lead['company']}")

# Step 2: Reason (LLM decides next action)
# LLM: "I need to enrich this lead first"

# Step 3: Act
enriched = enrich_lead(lead)
print(f"Enriched: revenue={enriched['revenue']}")

# Step 4: Feedback + Loop
# LLM: "Now I'll score"

# Step 5: Act
score = score_lead(enriched)
print(f"Score: {score}")

# Step 6: Reason
# LLM: "Score is {score}, should assign to top rep"

# Step 7: Act
best_rep = find_best_rep(score)
assign_lead(lead_id, best_rep)
send_notification(best_rep, f"New lead: {lead['company']}")

print(f"Assigned to {best_rep}")

def call_crm_api(endpoint, method="GET", data=None):
    url = f"https://api.crm.com/{endpoint}"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    if method == "GET":
        response = requests.get(url, headers=headers)
    elif method == "POST":
        response = requests.post(url, json=data, headers=headers)
    
    return response.json()

@app.post("/webhook/new_lead")
def on_new_lead(lead_data):
    # Trigger agent asynchronously
    queue.enqueue(lead_qualification_agent, lead_data['id'])
    return {"status": "queued"}

from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=100, period=60)  # 100 calls per minute
def call_api(endpoint):
    return requests.get(f"https://api.example.com/{endpoint}")

def get_customer_history(customer_id):
    query = "SELECT * FROM interactions WHERE customer_id = %s"
    return db.execute(query, (customer_id,))

def store_lead_score(lead_id, score, assigned_to):
    db.execute(
        "UPDATE leads SET score = %s, assigned_to = %s WHERE id = %s",
        (score, assigned_to, lead_id)
    )

with db.transaction():
    score = score_lead(lead)
    db.update_lead_score(lead_id, score)
    rep = find_best_rep(score)
    db.assign_lead(lead_id, rep)
    # All-or-nothing: if any step fails, rollback

from salesforce import SalesforceAPI

sf = SalesforceAPI(api_key=key)

# Update lead
sf.update_lead(lead_id, {
    'score': 85,
    'assigned_to': 'john@acme.com',
    'status': 'qualified'
})

from slack_sdk import WebClient

slack = WebClient(token=slack_token)

# Notify sales rep
slack.chat_postMessage(
    channel="john",
    text=f"New qualified lead: {lead['company']} (score: {score})"
)

# Agent can only read leads, update scores
# Cannot delete leads or access sensitive data
oauth_scopes = ["leads:read", "leads:update"]

if decision_risk_score > 0.7:
    # Route to human for approval
    escalate_to_human(decision, reason="High risk")
else:
    # Agent executes decision
    execute_decision(decision)

def lead_qualification_with_escalation(lead_id):
    score = score_lead(lead_id)
    
    if score > 80:
        # High confidence, assign directly
        assign_lead(lead_id, best_rep)
    elif 50 < score < 80:
        # Medium confidence, route to human
        escalate_to_human(lead_id, "Review and assign")
    else:
        # Low score, reject
        reject_lead(lead_id)

@app.post("/feedback/lead_score")
def on_score_feedback(lead_id, actual_score, agent_score):
    # Store feedback
    db.log_feedback(lead_id, agent_score, actual_score)
    
    # Retrain model on feedback (periodic)
    if should_retrain():
        retrain_scoring_model()

# Bad: Agent keeps calling same tool
Agent thinks: "I need to get lead data"
→ Calls get_lead()
→ Still doesn't have enriched data
→ Calls get_lead() again
→ Infinite loop

max_steps = 10
steps_taken = 0

while steps_taken < max_steps:
    action = llm.decide_next_action()
    
    if action == last_action:
        # Same action twice, break loop
        break
    
    execute_action(action)
    steps_taken += 1

try:
    result = agent.run(timeout=30)  # 30 second timeout
except TimeoutError:
    escalate_to_human("Agent loop timeout")

# Bad: Agent hallucinates tool output
Agent: "I called enrich_lead, got revenue=$100M"
Reality: enrich_lead() returned null (API failed)
Agent made up the result

def execute_tool_safely(tool_name, params):
    try:
        result = execute_tool(tool_name, params)
        
        # Validate result
        if result is None:
            return {"error": "Tool returned null"}
        
        if not validate_result(result):
            return {"error": "Result failed validation"}
        
        return result
    except Exception as e:
        return {"error": str(e)}

# Instead of: "Summarize this article"
# Use: "Summarize this article, citing specific passages"

knowledge_base = vector_db.search(query)
prompt = f"""
Summarize this article. Only cite specific passages.
Article: {article}
Knowledge base: {knowledge_base}
"""

def robust_agent_call(goal, retries=3):
    for attempt in range(retries):
        try:
            result = agent.run(goal)
            
            # Validate result
            if validate(result):
                return result
        except Exception as e:
            if attempt == retries - 1:
                escalate_to_human(goal)
            else:
                time.sleep(2 ** attempt)  # Backoff

# Bad: Ambiguous tool description
"update_lead - Update a lead"

# Good: Clear description
"update_lead - Update a lead's score, status, or assigned_to field. 
Parameters: lead_id (required), score (0-100), status (qualified/disqualified), 
assigned_to (sales rep email)"

# Validate before execution
tool_call = llm.decide_tool_call()

if not validate_tool_call(tool_call):
    # Tool call is invalid, ask LLM to fix
    llm.correct_tool_call(tool_call)
else:
    execute_tool(tool_call)

def validate_tool_call(call):
    tool = tools[call['name']]
    required_params = tool['required_parameters']
    
    for param in required_params:
        if param not in call['params']:
            return False
    
    return True

try:
    result = execute_tool(tool_call)
except ToolExecutionError as e:
    # Suggest correct tool
    correct_tool = suggest_correct_tool(e)
    llm.suggest_retry(correct_tool)

# Bad: Agent calls same tool multiple times
Agent: "Let me get lead data"
→ Calls get_lead()
→ Calls get_lead() again (forgot it already did)
→ Calls get_lead() a third time
Cost: 3x higher than needed

budget = {"tokens": 10000, "api_calls": 50}
spent = {"tokens": 0, "api_calls": 0}

def execute_with_budget(action):
    global spent
    
    if spent['api_calls'] >= budget['api_calls']:
        raise BudgetExceededError()
    
    result = execute_action(action)
    spent['api_calls'] += 1
    
    return result

cache = {}

def get_lead_cached(lead_id):
    if lead_id in cache:
        return cache[lead_id]
    
    result = crm_api.get_lead(lead_id)
    cache[lead_id] = result
    return result

if cost_this_hour > budget_per_hour:
    # Switch to cheaper model
    switch_to_model("gpt-3.5-turbo")  # Cheaper than GPT-4

# Parallel execution
import asyncio

async def parallel_agent(lead_id):
    lead = await get_lead_async(lead_id)
    
    # Call multiple tools in parallel
    enrichment, scoring = await asyncio.gather(
        enrich_lead_async(lead),
        score_lead_async(lead)
    )
    
    return (enrichment, scoring)

# Instead of GPT-4 (slower, more accurate)
# Use GPT-3.5-turbo (faster, still accurate enough)
model = "gpt-3.5-turbo"  # 200ms latency vs 500ms for GPT-4

try:
    result = agent.run(timeout=5)  # 5 second timeout
    return result
except TimeoutError:
    # Return partial results
    return partial_result
    # Queue for async completion
    queue.enqueue(complete_agent, lead_id)

correct = 0
total = 100

for decision in agent_decisions:
    if decision == human_review[decision.id]:
        correct += 1

accuracy = correct / total * 100  # e.g., 94%

start = time.time()
result = agent.run(input_data)
latency = time.time() - start  # e.g., 8.5 seconds

cost = (llm_api_calls * llm_cost) + (tool_calls * tool_cost) + (human_review_rate * hourly_rate)
# e.g., $0.03 per lead

automated = tasks_completed_by_agent
total = all_tasks
automation_rate = automated / total * 100  # e.g., 87%

# Track daily metrics
daily_metrics = {
    'accuracy': 0.94,
    'latency': 8.5,
    'cost_per_task': 0.03,
    'automation_rate': 0.87
}

# Test 1: GPT-4 (more accurate, slower)
# Test 2: GPT-3.5-turbo (faster, slightly less accurate)

# Measure: accuracy, latency, cost
# Choose based on your priorities

# Collect human feedback on agent mistakes
feedback = db.get_feedback()

# Retrain agent (adjust prompts, add examples)
agent.retrain(feedback)

# Measure: accuracy improves from 94% to 96%