Yuho Jeong

from agents import Agent

agent = Agent(
    name="Math Tutor",
    instructions="You provide help with math problems. Explain your reasoning at each step and include examples",
)

history_tutor_agent = Agent(
    name="History Tutor",
    handoff_description="Specialist agent for historical questions",
    instructions="You provide assistance with historical queries. Explain important events and context clearly.",
)

math_tutor_agent = Agent(
    name="Math Tutor",
    handoff_description="Specialist agent for math questions",
    instructions="You provide help with math problems. Explain your reasoning at each step and include examples",
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="You determine which agent to use based on the user's homework question",
    handoffs=[history_tutor_agent, math_tutor_agent]
)

from agents import Runner

async def main():
    result = await Runner.run(triage_agent, "What is the capital of France?")
    print(result.final_output)

from agents import GuardrailFunctionOutput, Agent, Runner
from pydantic import BaseModel


class HomeworkOutput(BaseModel):
    is_homework: bool
    reasoning: str

guardrail_agent = Agent(
    name="Guardrail check",
    instructions="Check if the user is asking about homework.",
    output_type=HomeworkOutput,
)

async def homework_guardrail(ctx, agent, input_data):
    result = await Runner.run(guardrail_agent, input_data, context=ctx.context)
    final_output = result.final_output_as(HomeworkOutput)
    return GuardrailFunctionOutput(
        output_info=final_output,
        tripwire_triggered=not final_output.is_homework,
    )
    
triage_agent = Agent(
    name="Triage Agent",
    instructions="You determine which agent to use based on the user's homework question",
    handoffs=[history_tutor_agent, math_tutor_agent],
    input_guardrails=[
        InputGuardrail(guardrail_function=homework_guardrail),
    ],
)

# 간단한 에이전트는 이름과 지침만으로 생성할 수 있습니다.
from agents import Agent

math_tutor_agent = Agent(
    name="Math Tutor",
    instructions="You provide help with math problems. Explain your reasoning at each step and include examples.",
    model="gpt-4o" # 사용할 모델을 명시적으로 지정
)

# Runner는 최종 출력이 나올 때까지 에이전트 루프를 자동으로 처리합니다.
from agents import Runner

# 위에서 정의한 math_tutor_agent를 가정합니다.
user_query = "What is the Pythagorean theorem?"

# 비동기 실행
result = await Runner.run(math_tutor_agent, user_query)

print(result.final_output)

# 스트리밍은 사용자에게 실시간 피드백을 제공합니다.
# 아래는 일반적인 스트리밍 패턴에 기반한 개념적 예제입니다.

async for event in Runner.run_streamed(agent, "Tell me a long story."):
    if event.type == 'text_delta':
        print(event.delta, end="", flush=True)
    elif event.type == 'final_output':
        print("\n--- Story Complete ---")

messages = []
messages.append({"role": "user", "content": "Remember the number 7814."})
response = runner.run(messages)
messages = runner.to_input_list(response)

messages.append({"role": "user", "content": "Multiply the last number by 103.8"})
response = runner.run(messages)
print(response)  # 이전 숫자를 기억하고 계산 수행

# @function_tool 데코레이터는 파이썬 함수를 즉시 도구로 변환합니다.
from agents import function_tool

@function_tool
def get_weather(city: str) -> str:
    """Returns the current weather for a specified city."""
    # 실제 애플리케이션에서는 이 부분에서 날씨 API를 호출합니다.
    return f"The weather in {city} is sunny and 25°C."

agent = Agent(
    name="날씨비서",
    instructions="너는 날씨 정보를 제공하는 도우미야.",
    tools=[get_weather]
)

@dataclass
class UserContext:
    name: str
    uid: str
    is_pro_user: bool

    async def fetch_purchases() -> list[Purchase]:
        return ...

agent = Agent[UserContext](
    ...,
)

import asyncio
from dataclasses import dataclass

from agents import Agent, RunContextWrapper, Runner, function_tool

@dataclass
class UserInfo:  
    name: str
    uid: int

@function_tool
async def fetch_user_age(wrapper: RunContextWrapper[UserInfo]) -> str:  
    """Fetch the age of the user. Call this function to get user's age information."""
    return f"The user {wrapper.context.name} is 47 years old"

async def main():
    user_info = UserInfo(name="John", uid=123)

    agent = Agent[UserInfo](  
        name="Assistant",
        tools=[fetch_user_age],
    )

    result = await Runner.run(  
        starting_agent=agent,
        input="What is the age of the user?",
        context=user_info,
    )

    print(result.final_output)  
    # The user John is 47 years old.

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

# 세션은 실행 간의 대화 기록을 자동으로 유지하고 가져옵니다.
from agents import Agent, Runner, SQLiteSession

assistant = Agent(name="Assistant", instructions="You are a helpful assistant.")
# 고유한 대화 ID와 연결된 세션 생성
session = SQLiteSession("user_conversation_42")

# 첫 번째 턴
await Runner.run(assistant, "My name is Alex.", session=session)

# 두 번째 턴 - 에이전트가 이름을 기억합니다.
result = await Runner.run(assistant, "What is my name?", session=session)
print(result.final_output) # 예상 출력: "Your name is Alex."

# triage_agent는 전문화된 에이전트로의 핸드오프를 구성합니다.
history_tutor_agent = Agent(name="History Tutor", instructions="...")
math_tutor_agent = Agent(name="Math Tutor", instructions="...")

triage_agent = Agent(
    name="Triage Agent",
    instructions="You determine which agent to use based on the user's homework question.",
    handoffs=[history_tutor_agent, math_tutor_agent]
)

# Runner는 LLM의 결정에 따라 핸드오프를 자동으로 처리합니다.
result = await Runner.run(triage_agent, "Who was Julius Caesar?")
# 결과는 history_tutor_agent로부터 생성됩니다.

from agents import Agent, handoff, RunContextWrapper

def on_handoff(ctx: RunContextWrapper[None]):
    print("Handoff called")

agent = Agent(name="My agent")

handoff_obj = handoff(
    agent=agent,
    on_handoff=on_handoff,
    tool_name_override="custom_handoff_tool",
    tool_description_override="Custom description",
)

from agents import Agent, handoff
from agents.extensions import handoff_filters

agent = Agent(name="FAQ agent")

handoff_obj = handoff(
    agent=agent,
    input_filter=handoff_filters.remove_all_tools, 
)

# 가드레일은 입력과 출력을 검증하는 강력한 방법을 제공합니다.
from agents import Agent, input_guardrail, GuardrailFunctionOutput, Runner
from agents.exceptions import InputGuardrailTripwireTriggered

@input_guardrail
async def profanity_check_guardrail(ctx, agent, input_data) -> GuardrailFunctionOutput:
    is_inappropriate = "badword" in str(input_data).lower()
    return GuardrailFunctionOutput(
        output_info={"reason": "Profanity detected"},
        tripwire_triggered=is_inappropriate,
    )

safe_agent = Agent(
    name="Safe Agent",
    instructions="You are a helpful and friendly assistant.",
    input_guardrails=[profanity_check_guardrail]
)

try:
    await Runner.run(safe_agent, "This is a badword query.")
except InputGuardrailTripwireTriggered as e:
    print(f"Guardrail tripped! Reason: {e.output_info}")

from agents import Agent, Runner, trace

async def main():
    agent = Agent(name="Joke generator", instructions="Tell funny jokes.")

    with trace("Joke workflow"): 
        first_result = await Runner.run(agent, "Tell me a joke")
        second_result = await Runner.run(agent, f"Rate this joke: {first_result.final_output}")
        print(f"Joke: {first_result.final_output}")
        print(f"Rating: {second_result.final_output}")

# REPL 유틸리티는 빠르고 상호작용적인 테스트에 완벽합니다.
import asyncio
from agents import Agent, run_demo_loop

async def main():
    agent = Agent(name="Assistant", instructions="You are a helpful assistant.")
    await run_demo_loop(agent)

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

import os

from agents import Agent, function_tool
from agents.mcp.server import MCPServerStdio
from agents.extensions.visualization import draw_graph

@function_tool
def get_weather(city: str) -> str:
    return f"The weather in {city} is sunny."

spanish_agent = Agent(
    name="Spanish agent",
    instructions="You only speak Spanish.",
)

english_agent = Agent(
    name="English agent",
    instructions="You only speak English",
)

current_dir = os.path.dirname(os.path.abspath(__file__))
samples_dir = os.path.join(current_dir, "sample_files")
mcp_server = MCPServerStdio(
    name="Filesystem Server, via npx",
    params={
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", samples_dir],
    },
)

triage_agent = Agent(
    name="Triage agent",
    instructions="Handoff to the appropriate agent based on the language of the request.",
    handoffs=[spanish_agent, english_agent],
    tools=[get_weather],
    mcp_servers=[mcp_server],
)

draw_graph(triage_agent)

# SDK는 LiteLLM을 통해 모델에 구애받지 않습니다.
import os
from agents import Agent
from agents.extensions.models.litellm_model import LitellmModel

# LiteLLM 모델 래퍼 구성
claude_model = LitellmModel(
    model="claude-3-opus-20240229",
    api_key=os.environ.get("ANTHROPIC_API_KEY") # 환경 변수에서 키 가져오기
)

claude_agent = Agent(
    name="Claude Assistant",
    instructions="You are a helpful assistant powered by Claude.",
    model=claude_model
)