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": "Sunny"}',
        "Tokyo": '{"temp": 18, "condition": "Cloudy"}',
    }
    return data.get(city, '{"temp": null, "condition": "Unknown"}')

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 درجة مئوية ومشمس، بينما في طوكيو 18 درجة مئوية وغائم.

import json
from openai import OpenAI

client = OpenAI()

def search_web(query: str) -> str:
    """محاكاة بحث على الويب."""
    mock_results = {
        "Tesla 2024 revenue": "إيرادات تسلا الإجمالية لعام 2024: 97.69 مليار دولار",
        "Tesla 2023 revenue": "إيرادات تسلا الإجمالية لعام 2023: 96.77 مليار دولار",
        "AAPL stock price": "سعر سهم آبل الحالي: 195.27 دولار، نسبة السعر إلى الأرباح: 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("ما كانت إيرادات تسلا لعام 2024 وما هو مقدار نموها على أساس سنوي؟")
print(f"\nالإجابة النهائية:\n{answer}")

[الخطوة 1] search_web({'query': 'Tesla 2024 revenue'})
  -> إيرادات تسلا الإجمالية لعام 2024: 97.69 مليار دولار
[الخطوة 2] search_web({'query': 'Tesla 2023 revenue'})
  -> إيرادات تسلا الإجمالية لعام 2023: 96.77 مليار دولار
[الخطوة 3] calculate({'expression': '(97.69 - 96.77) / 96.77 * 100'})
  -> 0.9508080206700424

الإجابة النهائية:
كانت إيرادات تسلا لعام 2024 97.69 مليار دولار، مقارنة بـ 96.77 مليار دولار في 2023.
يمثل هذا نموًا سنويًا بنسبة 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("اسمي بوب وأعمل في شركة أبل.")
print(f"الوكيل: {r1}")

agent.remember("اسم المستخدم: بوب، يعمل في شركة أبل.")

r2 = agent.chat("ما اسمي وأين أعمل؟")
print(f"الوكيل: {r2}")

الوكيل: سعدت بلقائك يا بوب! كيف يمكنني مساعدتك اليوم؟
[حفظ في الذاكرة] اسم المستخدم: بوب، يعمل في شركة أبل.
الوكيل: اسمك بوب، وأنت تعمل في شركة أبل.

import json
from openai import OpenAI

client = OpenAI()

# --- Tool Definitions ---

def search_web(query: str) -> str:
    """Simulate web search for real-time information."""
    mock_db = {
        "Tesla 2024 revenue": "Tesla 2024 total revenue: $97.69 billion, net income: $7.09 billion",
        "Tesla 2023 revenue": "Tesla 2023 total revenue: $96.77 billion, net income: $14.99 billion",
        "Tesla stock price": "TSLA current price: $352.00, market cap: $1.13 trillion",
    }
    for key, val in mock_db.items():
        if key.lower() in query.lower():
            return val
    return f"No specific results for: {query}"

def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    allowed = set("0123456789+-*/.() ")
    if all(c in allowed for c in expression):
        try:
            return str(eval(expression))
        except Exception as e:
            return f"Error: {e}"
    return "Invalid expression"

def run_code(code: str) -> str:
    """Execute Python code and return output."""
    import io
    import contextlib
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, {"__builtins__": {}})
        return output.getvalue() or "Code executed with no output."
    except Exception as e:
        return f"Execution error: {e}"

# --- Agent Setup ---

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

tool_schemas = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Search the web for real-time information like stock prices, revenue, news",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Evaluate a mathematical expression, e.g. (100-90)/90*100",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Math expression"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_code",
            "description": "Execute Python code for complex analysis, charting, or data processing",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {"type": "string", "description": "Python code to execute"}
                },
                "required": ["code"]
            }
        }
    }
]

SYSTEM_PROMPT = """You are a research assistant agent. When answering questions:
1. Use search_web to find real-time data
2. Use calculate for math operations
3. Use run_code for complex analysis
Always show your reasoning step by step."""

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 {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"Thought: {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"Action: {func_name}({json.dumps(func_args)})")

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

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

    return "Agent reached maximum steps."

# --- Run the Agent ---

answer = research_agent(
    "What was Tesla's 2024 revenue? How much did it grow year-over-year? "
    "Calculate the growth rate as a percentage."
)
print(f"\n{'='*50}\nFinal Answer:\n{answer}")

--- الخطوة 1 ---
الفكر: أحتاج إلى العثور على إيرادات تسلا لعامي 2024 و 2023 أولاً.
الإجراء: search_web({"query": "Tesla 2024 revenue"})
الملاحظة: إيرادات تسلا الإجمالية لعام 2024: 97.69 مليار دولار، صافي الدخل: 7.09 مليار دولار

--- الخطوة 2 ---
الإجراء: search_web({"query": "Tesla 2023 revenue"})
الملاحظة: إيرادات تسلا الإجمالية لعام 2023: 96.77 مليار دولار، صافي الدخل: 14.99 مليار دولار

--- الخطوة 3 ---
الإجراء: calculate({"expression": "(97.69 - 96.77) / 96.77 * 100"})
الملاحظة: 0.9508080206700424

==================================================
الإجابة النهائية:
كانت إيرادات تسلا الإجمالية لعام 2024 نحو 97.69 مليار دولار، مقارنة بـ 96.77 مليار دولار في عام 2023.
معدل النمو على أساس سنوي هو حوالي 0.95%.