الوكلاء ذاتيو التحسين

الوكلاء الأكثر إثارة للاهتمام لا ينفذون فقط—بل يتعلمون من أخطائهم. التحسين الذاتي هو حدود تطوير الوكلاء في 2025.

حلقة التعلم

تنفيذ → مراقبة النتيجة → تحليل الفشل → تحديث الاستراتيجية → تنفيذ أفضل

هذا ليس مجرد منطق إعادة المحاولة. إنها وكلاء تحسن نهجها بناءً على ما نجح وما لم ينجح.

أنماط التأمل

بعد كل مهمة، الوكيل يتأمل في أدائه:

class ReflectiveAgent:
    def __init__(self, model: str = "claude-sonnet-4-20250514"):
        self.model = model
        self.experience_log = []

    async def execute_with_reflection(self, task: str) -> dict:
        """تنفيذ المهمة والتعلم من النتيجة."""

        # الخطوة 1: تنفيذ المهمة
        result = await self.execute_task(task)

        # الخطوة 2: التأمل في التنفيذ
        reflection = await self.reflect(task, result)

        # الخطوة 3: تخزين التعلم
        self.experience_log.append({
            "task": task,
            "result": result,
            "reflection": reflection,
            "timestamp": datetime.now()
        })

        return {"result": result, "reflection": reflection}

    async def reflect(self, task: str, result: dict) -> dict:
        """توليد تأمل على تنفيذ المهمة."""
        response = await llm.chat(
            model=self.model,
            messages=[{
                "role": "user",
                "content": f"""تأمل في تنفيذ هذه المهمة:

المهمة: {task}
النتيجة: {json.dumps(result, indent=2)}
النجاح: {result.get('success', False)}

حلل:
1. ما الذي سار بشكل جيد؟
2. ما الذي يمكن تحسينه؟
3. ما الذي ستفعله بشكل مختلف المرة القادمة؟
4. ما الأنماط التي يجب تذكرها؟

أرجع JSON بمفاتيح: went_well، improvements، next_time، patterns"""
            }]
        )
        return json.loads(response.content)

التحفيز المبني على الخبرة

استخدم الخبرات السابقة لتحسين الأداء المستقبلي:

class ExperienceAugmentedAgent:
    def __init__(self):
        self.experience_store = []

    async def build_context_from_experience(self, task: str) -> str:
        """إيجاد خبرات سابقة ذات صلة لتضمينها في السياق."""

        # إيجاد مهام سابقة مشابهة
        similar = await self.find_similar_experiences(task, limit=3)

        if not similar:
            return ""

        context_parts = ["## خبرات سابقة ذات صلة\n"]

        for exp in similar:
            context_parts.append(f"""
### مهمة مشابهة: {exp['task'][:100]}...
- النتيجة: {'نجاح' if exp['result']['success'] else 'فشل'}
- الدرس الرئيسي: {exp['reflection'].get('patterns', 'لا شيء مسجل')}
- ما يجب تجنبه: {exp['reflection'].get('improvements', 'لا شيء مسجل')}
""")

        return "\n".join(context_parts)

    async def execute(self, task: str) -> dict:
        """تنفيذ مع سياق معزز بالخبرة."""
        experience_context = await self.build_context_from_experience(task)

        system_prompt = f"""أنت وكيل ذكاء اصطناعي يتعلم من الخبرة.

{experience_context}

طبق هذه الدروس على المهمة الحالية. تجنب الأخطاء السابقة وابنِ على الأنماط الناجحة."""

        return await self.run_with_prompt(system_prompt, task)

تعلم اختيار الأدوات

تتبع أي أدوات تعمل بشكل أفضل لأي مهام:

class ToolLearner:
    def __init__(self):
        self.tool_success_rates = {}  # (task_type, tool) -> success_rate
        self.tool_sequences = {}       # task_type -> [successful sequences]

    def record_tool_usage(self, task_type: str, tools_used: list[str], success: bool):
        """تعلم أي أدوات تعمل لأي مهام."""
        for tool in tools_used:
            key = (task_type, tool)
            if key not in self.tool_success_rates:
                self.tool_success_rates[key] = {"successes": 0, "total": 0}

            self.tool_success_rates[key]["total"] += 1
            if success:
                self.tool_success_rates[key]["successes"] += 1

        # تسجيل التسلسلات الناجحة
        if success:
            if task_type not in self.tool_sequences:
                self.tool_sequences[task_type] = []
            self.tool_sequences[task_type].append(tools_used)

    def get_recommended_tools(self, task_type: str) -> list[str]:
        """توصية بأدوات بناءً على النجاح السابق."""
        relevant = [
            (tool, stats["successes"] / stats["total"])
            for (t, tool), stats in self.tool_success_rates.items()
            if t == task_type and stats["total"] >= 3
        ]
        # ترتيب حسب معدل النجاح
        relevant.sort(key=lambda x: x[1], reverse=True)
        return [tool for tool, _ in relevant[:5]]

تطور البرومبت

وكلاء يحسنون برومبتاتهم الخاصة:

class PromptEvolver:
    def __init__(self):
        self.prompt_versions = {}  # prompt_id -> [versions]
        self.prompt_scores = {}    # (prompt_id, version) -> score

    async def evolve_prompt(self, prompt_id: str, current_prompt: str, feedback: list[dict]) -> str:
        """توليد برومبت محسن بناءً على التغذية الراجعة."""

        feedback_summary = "\n".join([
            f"- المهمة: {f['task'][:50]}... | النجاح: {f['success']} | المشكلة: {f.get('issue', 'لا شيء')}"
            for f in feedback[-10:]  # آخر 10 تفاعلات
        ])

        response = await llm.chat(
            model="claude-sonnet-4-20250514",
            messages=[{
                "role": "user",
                "content": f"""حسّن برومبت النظام هذا بناءً على التغذية الراجعة.

البرومبت الحالي:
{current_prompt}

التغذية الراجعة الأخيرة:
{feedback_summary}

أنشئ نسخة محسنة:
1. تعالج الإخفاقات المذكورة
2. تعزز الأنماط الناجحة
3. تضيف توجيهاً محدداً لمناطق المشاكل
4. تبقى موجزة وواضحة

أرجع نص البرومبت المحسن فقط."""
            }]
        )

        new_prompt = response.content
        version = len(self.prompt_versions.get(prompt_id, [])) + 1
        self.prompt_versions.setdefault(prompt_id, []).append(new_prompt)

        return new_prompt

وكيل التعلم الفوقي

وكيل يتعلم كيف يتعلم:

class MetaLearningAgent:
    def __init__(self):
        self.learning_strategies = [
            "reflection_after_failure",
            "experience_augmentation",
            "tool_preference_learning",
            "prompt_evolution"
        ]
        self.strategy_effectiveness = {s: [] for s in self.learning_strategies}

    async def select_learning_strategy(self, context: dict) -> str:
        """اختيار استراتيجية التعلم للتطبيق."""
        # تحليل أي استراتيجيات كانت الأكثر فعالية
        strategy_scores = {}
        for strategy, results in self.strategy_effectiveness.items():
            if results:
                strategy_scores[strategy] = sum(results[-10:]) / len(results[-10:])
            else:
                strategy_scores[strategy] = 0.5  # درجة افتراضية لغير المجربة

        # اختيار أفضل استراتيجية مع بعض الاستكشاف
        if random.random() < 0.1:  # 10% استكشاف
            return random.choice(self.learning_strategies)
        else:
            return max(strategy_scores, key=strategy_scores.get)

ملاحظة نيردية: الوكلاء ذاتيو التحسين قويون لكن يحتاجون حواجز. وكيل يعدل برومبتاته الخاصة قد ينحرف بطرق غير متوقعة. دائماً سجل التغييرات واحتفظ بقدرة التراجع.

التالي: كيف تعمل الوكلاء معاً في أنظمة بيئية. :::