دمج الوكيل مع نماذج اللغة الكبيرة (LLM) كـ"عقل"

1. ما معنى أن يكون للوكيل "عقل"؟

تخيل وكيلنا ككيان رقمي. حلقة العمل التي بنيناها هي بمثابة الجهاز العصبي الذي يبقيه نشطاً. لكن ما الذي يتخذ القرارات؟ هذا هو دور "العقل". في عالم وكلاء الذكاء الاصطناعي، يلعب نموذج اللغة الكبير (LLM) هذا الدور.

سنقوم بربط وكيلنا بواجهة برمجة تطبيقات (API) خاصة بنموذج لغوي (مثل GPT من OpenAI). عندما يحتاج الوكيل إلى "التفكير"، سنرسل ملاحظته (سؤال المستخدم مثلاً) إلى الـ LLM عبر الإنترنت، وسيرد علينا الـ LLM بـ "فكرة" أو "قرار". سيأخذ وكيلنا هذا الرد ويستخدمه كأساس لخطوته التالية.

2. إعداد الاتصال بالـ LLM

للتواصل مع أي خدمة عبر الإنترنت مثل OpenAI API، نحتاج إلى شيئين رئيسيين: مكتبة برمجية لتسهيل الاتصال، وطريقة للمصادقة (إثبات هويتنا).

أ. تثبيت المكتبة وإعداد مفتاح API

في الوحدة الثانية، تعلمنا عن واجهات برمجة التطبيقات (APIs) وأهمية مفاتيح API للحماية والمصادقة. سنستخدم الآن تلك المفاهيم بشكل عملي.

1. تثبيت مكتبة OpenAI: افتح الطرفية (Terminal) في VS Code وتأكد من أنك داخل البيئة الافتراضية (.venv)، ثم قم بتشغيل الأمر التالي:

   pip install openai
   

   إذا كنت قد ثبّت مكتبة python-dotenv في الوحدة الثانية، فلا داعي لتثبيتها مرة أخرى. إن لم تكن مثبتة، قم بتشغيل pip install python-dotenv.

2. الحصول على مفتاح API: ستحتاج إلى مفتاح API من OpenAI.

   • اذهب إلى platform.openai.com/api-keys.
   • أنشئ حساباً أو سجل الدخول.
   • اضغط على "Create new secret key"، أعطه اسماً (مثلاً MyAgentKey)، ثم انسخ المفتاح الذي يظهر لك. ملاحظة مهمة: هذا المفتاح يظهر مرة واحدة فقط، فاحتفظ به في مكان آمن مؤقتاً.

3. تخزين المفتاح بأمان: كما تعلمنا، لا يجب أبداً كتابة المفاتيح الحساسة مباشرة في الكود. سنستخدم ملف متغيرات البيئة (.env). في نفس مجلد مشروعك، أنشئ ملفاً جديداً باسم .env (نعم، يبدأ بنقطة ولا يوجد اسم قبله) وأضف إليه السطر التالي، مستبدلاً sk-... بالمفتاح الذي نسخته:

   OPENAI_API_KEY="sk-..."
   

للحصول على توضيح مرئي لهذه الخطوات، يمكنك مشاهدة هذا المقطع القصير.

ب. اختبار الاتصال

قبل دمج الـ LLM في وكيلنا، دعنا نتأكد من أن كل شيء يعمل بشكل صحيح عبر كتابة برنامج صغير ومستقل للاختبار.

بناءً على ما قرأت، يمكنك إنشاء ملف جديد باسم test_llm.py وكتابة الكود التالي لتجربته بنفسك:

# test_llm.py

import os
from openai import OpenAI
from dotenv import load_dotenv

# تحميل متغيرات البيئة من ملف .env
load_dotenv()

# إنشاء عميل OpenAI. سيقرأ المفتاح تلقائياً من متغير البيئة OPENAI_API_KEY
client = OpenAI()

print("إرسال طلب إلى OpenAI...")

# إرسال طلب بسيط إلى النموذج
chat_completion = client.chat.completions.create(
    model="gpt-3.5-turbo",  # يمكنك استخدام نماذج أخرى مثل "gpt-4o"
    messages=[
        {
            "role": "user", 
            "content": "مرحباً! من أنت؟"
        }
    ]
)

# طباعة الرد المستلم من النموذج
response_content = chat_completion.choices[0].message.content
print("الرد المستلم:")
print(response_content)

قم بتشغيل هذا الملف (python test_llm.py). إذا تم كل شيء بشكل صحيح، يجب أن ترى رداً من ChatGPT، مما يؤكد أن مفتاحك وإعداداتك صحيحة!

3. دمج "العقل" في وكيلنا

الآن بعد أن تأكدنا من أن الاتصال يعمل، حان الوقت لدمج هذه القدرة في فئة Agent التي بنيناها. سنقوم بتحديث ملف agent_v1.py من الدرس السابق ونحفظه باسم agent_v2.py.

التغيير الجوهري سيكون في التابع think. بدلاً من أن يقرر بشكل ثابت، سيقوم الآن باستدعاء الـ LLM.

# agent_v2.py

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

class Agent:
    """
    نسخة مطورة من الوكيل، متصلة بـ LLM كـ 'عقل'.
    """
    def __init__(self, goal):
        print(f"تم إنشاء وكيل جديد بهدف: '{goal}'")
        self.goal = goal
        self.memory = []
        self.is_done = False
        # إنشاء عميل OpenAI عند إنشاء الوكيل
        self.llm_client = OpenAI()
        # إعطاء هوية للوكيل من خلال 'System Prompt'
        self.system_prompt = "أنت مساعد ذكي ومفيد. مهمتك هي تحليل الملاحظات واتخاذ قرار حول الخطوة التالية."
        self.conversation_history = [{"role": "system", "content": self.system_prompt}]


    def think(self, observation):
        """
        خطوة التفكير: يستخدم الوكيل الـ LLM ليقرر ما يجب فعله.
        """
        print(f"🤔 الوكيل يفكر في الملاحظة: '{observation}'")

        # إضافة ملاحظة المستخدم إلى سجل المحادثة
        self.conversation_history.append({"role": "user", "content": observation})
        
        # استدعاء الـ LLM للحصول على القرار
        chat_completion = self.llm_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=self.conversation_history
        )
        
        decision = chat_completion.choices[0].message.content
        print(f"🧠 قرار الـ LLM: '{decision}'")
        
        # إضافة رد المساعد (القرار) إلى سجل المحادثة
        self.conversation_history.append({"role": "assistant", "content": decision})

        return decision

    def act(self, decision):
        """
        خطوة التصرف: ينفذ الوكيل القرار.
        حالياً، التصرف هو ببساطة عرض القرار كإجابة نهائية.
        """
        print(f"🏃 الوكيل يتصرف بناءً على القرار...")
        # في هذا الإصدار، الإجابة هي نفسها القرار الذي اتخذه الـ LLM
        response = decision
        return response

    def run(self, initial_observation):
        """
        الحلقة الرئيسية التي تدير عمل الوكيل.
        """
        print("\n--- بدء حلقة عمل الوكيل الذكي ---")
        
        observation = initial_observation
        turn_count = 0

        while not self.is_done:
            turn_count += 1
            print(f"\n--- الجولة رقم {turn_count} ---")
            
            # 1. التفكير (الآن باستخدام LLM)
            decision = self.think(observation)

            # 2. التصرف (بناءً على قرار الـ LLM)
            result = self.act(decision)
            print(f"💬 النتيجة النهائية: {result}")
            
            # في هذا المثال البسيط، سنتوقف بعد جولة واحدة فقط.
            if turn_count >= 1:
                print("\nالوكيل قرر أن مهمته قد اكتملت.")
                self.is_done = True

        print("\n--- انتهاء حلقة عمل الوكيل ---")


# --- الجزء الرئيسي من البرنامج ---
if __name__ == "__main__":
    my_agent = Agent("الإجابة على أسئلة المستخدم بذكاء")
    my_agent.run("ما هي عاصمة فرنسا؟ وكيف هو الطقس فيها اليوم؟")

تحليل التغييرات الرئيسية:

1. __init__:

   • نقوم الآن بإنشاء self.llm_client = OpenAI() مرة واحدة عند إنشاء الوكيل.
   • أضفنا system_prompt، وهو توجيه أولي نعطيه للـ LLM ليحدد "شخصيته" أو دوره.
   • أنشأنا self.conversation_history وهي قائمة ستحتفظ بسياق الحوار مع الـ LLM.

2. think(self, observation): هذا هو التابع الذي تغير بالكامل.

   • لم يعد يتبع قاعدة ثابتة.
   • يقوم بإضافة ملاحظة المستخدم إلى self.conversation_history.
   • يستدعي self.llm_client.chat.completions.create ويمرر له سجل المحادثة بالكامل.
   • يستخلص الرد من الـ LLM ويعيده ليكون "القرار".
   • يضيف رد الـ LLM إلى السجل للحفاظ على السياق للجولات القادمة.

3. act(self, decision): الآن، هذا التابع يأخذ القرار الذكي من think وينفذه. في مثالنا الحالي، التنفيذ هو مجرد عرض هذا القرار. لاحقاً، يمكن أن يكون التنفيذ هو استدعاء أداة.

عند تشغيل هذا الكود (python agent_v2.py)، لاحظ كيف أن المخرجات لم تعد ثابتة. لقد سألت الوكيل سؤالاً، وهو "فكر" فيه باستخدام GPT وقدم إجابة ذكية.

خلاصة الدرس

لقد حققت اليوم قفزة نوعية! وكيلك لم يعد مجرد هيكل برمجي، بل أصبح يمتلك عقلاً قادراً على التفكير.

أهم النقاط التي تعلمناها:

• نماذج اللغة الكبيرة (LLMs) تعمل كـ "عقل" أو "محرك قرار" للوكلاء.
• نحن نتواصل مع الـ LLMs عبر واجهات برمجة التطبيقات (APIs) باستخدام مكتبات متخصصة مثل openai.
• مفاتيح API ضرورية للمصادقة ويجب الحفاظ عليها آمنة باستخدام ملفات .env.
• يمكننا دمج استدعاء الـ LLM مباشرة في حلقة عمل الوكيل (تحديداً في خطوة "التفكير") لمنحه قدرات ديناميكية.
• الـ "System Prompt" هو أداة قوية لتشكيل شخصية وسلوك الوكيل.

ماذا بعد؟

وكيلنا الآن ذكي، لكنه ينسى كل شيء بمجرد انتهاء المحادثة. قائمة conversation_history التي أنشأناها هي شكل بدائي جداً من الذاكرة، ولكنها تعمل فقط داخل استدعاء run واحد وتضيع بعد ذلك.

في الدرس القادم، سنتعمق في موضوع الذاكرة. سنتعلم كيف نبني نظام ذاكرة بسيط قصير المدى (Short-Term Memory)، مما يسمح لوكيلنا بتذكر المعلومات عبر جولات متعددة في نفس الجلسة. هذا سيجعله قادراً على خوض محادثات أكثر منطقية وترابطاً.