AI: AI エージェント

import json

def get_weather(city: str) -> str:
    """都市の現在の天気を取得する。"""
    weather_data = {
        "Beijing": '{"temp": 22, "condition": "晴れ"}',
        "Tokyo": '{"temp": 18, "condition": "曇り"}',
        "New York": '{"temp": 15, "condition": "雨"}',
    }
    return weather_data.get(city, '{"temp": null, "condition": "不明"}')

tool_definition = {
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "指定した都市の現在の天気を取得する",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "都市名（例：Beijing、Tokyo）"
                }
            },
            "required": ["city"]
        }
    }
}

print(get_weather("Beijing"))

{"temp": 22, "condition": "晴れ"}

from openai import OpenAI

client = OpenAI()

tools = [tool_definition]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "北京の天気は？"}
    ],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    func_name = tool_call.function.name
    func_args = json.loads(tool_call.function.arguments)

    print(f"モデルが呼び出しを希望: {func_name}")
    print(f"引数: {func_args}")

    result = get_weather(**func_args)
    print(f"ツール結果: {result}")

モデルが呼び出しを希望: get_weather
引数: {'city': 'Beijing'}
ツール結果: {"temp": 22, "condition": "晴れ"}

import json
from openai import OpenAI

client = OpenAI()

def get_weather(city: str) -> str:
    """都市の現在の天気を取得する。"""
    data = {
        "Beijing": '{"temp": 22, "condition": "晴れ"}',
        "Tokyo": '{"temp": 18, "condition": "曇り"}',
    }
    return data.get(city, '{"temp": null, "condition": "不明"}')

available_tools = {
    "get_weather": get_weather,
}

tool_schemas = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "指定した都市の現在の天気を取得する",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "都市名"}
            },
            "required": ["city"]
        }
    }
}]

def run_agent(user_query: str, max_steps: int = 5) -> str:
    messages = [{"role": "user", "content": user_query}]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"[ステップ {step+1}] 呼び出し {func_name}({func_args})")

            result = available_tools[func_name](**func_args)

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "エージェントは最大ステップに達しても最終回答に至りませんでした。"

answer = run_agent("北京と東京の天気は？")
print(answer)

[ステップ 1] 呼び出し get_weather({'city': 'Beijing'})
[ステップ 2] 呼び出し get_weather({'city': 'Tokyo'})
北京の天気は 22°C で晴れ、東京は 18°C で曇りです。

import json
from openai import OpenAI

client = OpenAI()

def search_web(query: str) -> str:
    """ウェブ検索をシミュレート。"""
    mock_results = {
        "Tesla 2024 revenue": "Tesla 2024 総収益: $97.69 billion",
        "Tesla 2023 revenue": "Tesla 2023 総収益: $96.77 billion",
        "AAPL stock price": "AAPL 現在株価: $195.27、PER: 31.2",
    }
    for key, val in mock_results.items():
        if key.lower() in query.lower():
            return val
    return "該当結果なし: " + query

def calculate(expression: str) -> str:
    """数式を安全に評価する。"""
    allowed = set("0123456789+-*/.() ")
    if all(c in allowed for c in expression):
        try:
            result = eval(expression)
            return str(result)
        except Exception as e:
            return f"計算エラー: {e}"
    return "無効な式"

available_tools = {
    "search_web": search_web,
    "calculate": calculate,
}

tool_schemas = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "情報をウェブで検索する",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "検索クエリ"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "数式を評価する",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "評価する数式"}
                },
                "required": ["expression"]
            }
        }
    }
]

def run_multi_tool_agent(user_query: str, max_steps: int = 10) -> str:
    messages = [{"role": "user", "content": user_query}]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"[ステップ {step+1}] {func_name}({func_args})")

            result = available_tools[func_name](**func_args)
            print(f"  -> {result}")

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "エージェントは最大ステップに達しました。"

answer = run_multi_tool_agent("Tesla の 2024 年収益はいくらで、前年比でどれだけ成長しましたか？")
print(f"\n最終回答:\n{answer}")

[ステップ 1] search_web({'query': 'Tesla 2024 revenue'})
  -> Tesla 2024 総収益: $97.69 billion
[ステップ 2] search_web({'query': 'Tesla 2023 revenue'})
  -> Tesla 2023 総収益: $96.77 billion
[ステップ 3] calculate({'expression': '(97.69 - 96.77) / 96.77 * 100'})
  -> 0.9508080206700424

最終回答:
Tesla の 2024 年収益は $97.69 billion で、2023 年の $96.77 billion と比べて
前年比成長率は約 0.95% です。

import json
from openai import OpenAI

client = OpenAI()

class MemoryAgent:
    def __init__(self, system_prompt: str = "あなたは親切なアシスタントです。"):
        self.system_prompt = system_prompt
        self.short_term_memory: list = []
        self.long_term_memory: list = []

    def add_to_long_term(self, fact: str):
        self.long_term_memory.append(fact)
        print(f"[記憶保存] {fact}")

    def get_context(self) -> list:
        context = [{"role": "system", "content": self.system_prompt}]
        if self.long_term_memory:
            mem_str = "\n".join(f"- {m}" for m in self.long_term_memory)
            context.append({
                "role": "system",
                "content": f"長期メモリ:\n{mem_str}"
            })
        context.extend(self.short_term_memory)
        return context

    def chat(self, user_input: str) -> str:
        self.short_term_memory.append({"role": "user", "content": user_input})

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=self.get_context()
        )
        reply = response.choices[0].message.content
        self.short_term_memory.append({"role": "assistant", "content": reply})
        return reply

    def remember(self, fact: str):
        self.add_to_long_term(fact)

agent = MemoryAgent(system_prompt="あなたは研究アシスタントです。")

r1 = agent.chat("私の名前は Bob で、Apple Inc. に勤めています。")
print(f"Agent: {r1}")

agent.remember("ユーザー名: Bob、勤務先: Apple Inc.")

r2 = agent.chat("私の名前と勤務先は？")
print(f"Agent: {r2}")

Agent: はじめまして、Bob さん！今日はどのようにお手伝いできますか？
[記憶保存] ユーザー名: Bob、勤務先: Apple Inc.
Agent: お名前は Bob さんで、勤務先は Apple Inc. です。

import json
from openai import OpenAI

client = OpenAI()

# --- ツール定義 ---

def search_web(query: str) -> str:
    """リアルタイム情報のウェブ検索をシミュレート。"""
    mock_db = {
        "Tesla 2024 revenue": "Tesla 2024 総収益: $97.69 billion、純利益: $7.09 billion",
        "Tesla 2023 revenue": "Tesla 2023 総収益: $96.77 billion、純利益: $14.99 billion",
        "Tesla stock price": "TSLA 現在株価: $352.00、時価総額: $1.13 trillion",
    }
    for key, val in mock_db.items():
        if key.lower() in query.lower():
            return val
    return f"特定の結果なし: {query}"

def calculate(expression: str) -> str:
    """数式を評価する。"""
    allowed = set("0123456789+-*/.() ")
    if all(c in allowed for c in expression):
        try:
            return str(eval(expression))
        except Exception as e:
            return f"エラー: {e}"
    return "無効な式"

def run_code(code: str) -> str:
    """Python コードを実行し出力を返す。"""
    import io
    import contextlib
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, {"__builtins__": {}})
        return output.getvalue() or "出力なしでコードが実行されました。"
    except Exception as e:
        return f"実行エラー: {e}"

# --- エージェント設定 ---

available_tools = {
    "search_web": search_web,
    "calculate": calculate,
    "run_code": run_code,
}

tool_schemas = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "株価、収益、ニュースなどのリアルタイム情報をウェブで検索する",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "検索クエリ"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "数式を評価する（例：(100-90)/90*100）",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "数式"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_code",
            "description": "複雑な分析、チャート、データ処理のための Python コードを実行する",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {"type": "string", "description": "実行する Python コード"}
                },
                "required": ["code"]
            }
        }
    }
]

SYSTEM_PROMPT = """あなたはリサーチアシスタントエージェントです。質問に答える際：
1. search_web を使ってリアルタイムデータを探す
2. calculate を使って数式演算する
3. run_code を使って複雑な分析をする
常に推論ステップを順に示すこと。"""

def research_agent(user_query: str, max_steps: int = 10) -> str:
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_query}
    ]

    for step in range(max_steps):
        print(f"\n--- ステップ {step + 1} ---")

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if msg.content:
            print(f"思考: {msg.content[:200]}")

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"行動: {func_name}({json.dumps(func_args)})")

            result = available_tools[func_name](**func_args)
            print(f"観察: {result[:200]}")

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "エージェントは最大ステップに達しました。"

# --- エージェントを実行 ---

answer = research_agent(
    "Tesla の 2024 年収益はいくら？前年比でどれだけ成長しましたか？"
    "成長率をパーセントで計算してください。"
)
print(f"\n{'='*50}\n最終回答:\n{answer}")

--- ステップ 1 ---
思考: まず Tesla の 2024 年と 2023 年の収益を見つける必要がある。
行動: search_web({"query": "Tesla 2024 revenue"})
観察: Tesla 2024 総収益: $97.69 billion、純利益: $7.09 billion

--- ステップ 2 ---
行動: search_web({"query": "Tesla 2023 revenue"})
観察: Tesla 2023 総収益: $96.77 billion、純利益: $14.99 billion

--- ステップ 3 ---
行動: calculate({"expression": "(97.69 - 96.77) / 96.77 * 100"})
観察: 0.9508080206700424

==================================================
最終回答:
Tesla の 2024 年総収益は $97.69 billion で、2023 年の $96.77 billion と比べて
前年比成長率は約 0.95% です。