كيف جعلنا تكاليف وكيل البرمجة قابلة للتوقع

كيف جعلنا إنفاق وكيل البرمجة قابلاً للتوقع

أحدثت وكلاء البرمجة المدعومة بنماذج اللغة الكبيرة (LLMs) تحولاً في تطوير البرمجيات، حيث أتمتت المهام بدءاً من توليد الأكواد وصولاً إلى تصحيح الأخطاء. ومع ذلك، كان التحدي المستمر يتمثل في عدم توقع التكاليف: حيث يمكن أن يرتفع استخدام الرموز (tokens) بشكل مفاجئ، مما يؤدي إلى تجاوز الميزانية واحتكاك تشغيلي. بالاستفادة من رؤى مدونة LangChain وأخبار OpenAI ومدونة Microsoft AI، تشرح هذه المقالة نهجاً عملياً لجعل إنفاق وكلاء البرمجة قابلاً للتوقع. سنغطي البنية التحتية، والتركيب خطوة بخطوة، وأمثلة استخدام ملموسة - وكلها مصممة لمنحك التحكم في التكاليف دون التضحية بالأداء.

المشكلة: لماذا إنفاق الوكيل غير متوقع

غالباً ما تعتمد وكلاء البرمجة على استدعاءات LLM ديناميكية تتباين بشكل كبير في استهلاك الرموز. قد تستخدم مراجعة كود معقدة واحدة 10,000 رمز، بينما يستخدم تعديل بسيط 200 رمز. بدون ضوابط، يمكن أن تتضخم التكاليف بسبب:

• **نوافذ السياق غير المحدودة**: قد يحتفظ الوكلاء بسجلات المحادثة الكاملة، مما يضخم رموز الإدخال.
• **سلوكيات التكرار**: يمكن للوكلاء إعادة استدعاء أنفسهم، مما يضاعف استدعاءات API.
• **المخرجات المفرطة في الهندسة**: تولد LLM أحياناً تفسيرات مطولة أو أكواداً غير ضرورية.

يكمن الحل في خط أنابيب منظم يفرض ميزانيات الرموز، ويخزن الاستجابات مؤقتاً، ويراقب الاستخدام في الوقت الفعلي. أدناه، نوضح كيفية بناء مثل هذا النظام باستخدام أدوات مفتوحة المصدر وأفضل الممارسات من الصناعة.

المتطلبات

قبل أن نبدأ، تأكد من توفر ما يلي:

• **Python 3.10+** مثبتة (قم بالتنزيل من python.org)
• **مفتاح OpenAI API** (أو مفتاح مزود LLM آخر، مثل Anthropic)
• **مدير الحزم pip** (يأتي مع Python)
• **Git** للتحكم في الإصدارات (اختياري لكن موصى به)
• محرر أكواد (VS Code، PyCharm، أو ما شابه)

سنستخدم هذه المكتبات الرئيسية:

• `langchain`: لتنسيق الوكيل وتتبع الرموز
• `tiktoken`: لحساب الرموز (أداة tokenizer من OpenAI)
• `redis`: لتخزين استجابات LLM مؤقتاً (اختياري لكن موصى به)
• `prometheus-client`: للمقاييس في الوقت الفعلي

التركيب خطوة بخطوة

اتبع هذه الخطوات لإعداد وكيل برمجة بتكاليف قابلة للتوقع.

الخطوة 1: إنشاء بيئة افتراضية

اعزل التبعيات لتجنب التعارضات.

python -m venv codingagent
source codingagent/bin/activate  # على Windows: codingagent\Scripts\activate

الخطوة 2: تثبيت الحزم المطلوبة

قم بتثبيت المكتبات الأساسية عبر pip.

pip install langchain openai tiktoken redis prometheus-client

الخطوة 3: تعيين متغيرات البيئة

قم بتخزين مفتاح API الخاص بك بشكل آمن. أنشئ ملف `.env` في جذر مشروعك.

echo "OPENAI_API_KEY=sk-your-key-here" > .env
echo "REDIS_URL=redis://localhost:6379" >> .env

ثم قم بتحميلها في الكود الخاص بك باستخدام `python-dotenv`:

pip install python-dotenv

الخطوة 4: تكوين مدير ميزانية الرموز

أنشئ ملف Python باسم `budget_manager.py` لفرض حدود الإنفاق.

import os
import tiktoken
from dotenv import load_dotenv

load_dotenv()

class TokenBudgetManager:
    def __init__(self, max_tokens_per_call=2000, max_total_tokens=50000):
        self.max_tokens_per_call = max_tokens_per_call
        self.max_total_tokens = max_total_tokens
        self.total_used = 0
        self.encoder = tiktoken.encoding_for_model("gpt-4")

    def count_tokens(self, text: str) -> int:
        return len(self.encoder.encode(text))

    def can_call(self, input_text: str) -> bool:
        input_tokens = self.count_tokens(input_text)
        if input_tokens + self.max_tokens_per_call > self.max_total_tokens - self.total_used:
            return False
        return True

    def record_usage(self, tokens_used: int):
        self.total_used += tokens_used
        if self.total_used >= self.max_total_tokens * 0.8:
            print("تحذير: تم استخدام 80% من الميزانية الإجمالية")

الخطوة 5: تنفيذ طبقة تخزين مؤقت

قم بتخزين استدعاءات LLM المتطابقة مؤقتاً لتجنب الإنفاق المكرر. استخدم Redis للإنتاج.

import redis
import json

cache = redis.Redis.from_url(os.getenv("REDIS_URL", "redis://localhost:6379"))

def cached_llm_call(prompt: str, model="gpt-4") -> str:
    cache_key = f"llm:{prompt}"
    cached = cache.get(cache_key)
    if cached:
        return json.loads(cached)
    
    from langchain.chat_models import ChatOpenAI
    llm = ChatOpenAI(model=model, temperature=0)
    response = llm.predict(prompt)
    
    cache.setex(cache_key, 3600, json.dumps(response))  # تخزين لمدة ساعة
    return response

الخطوة 6: بناء وكيل البرمجة مع ضوابط الإنفاق

الآن قم بدمج كل شيء في فئة وكيل البرمجة.

from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate

class SpendControlledCodingAgent:
    def __init__(self, budget_manager: TokenBudgetManager):
        self.budget = budget_manager
        self.llm = ChatOpenAI(model="gpt-4", temperature=0)
        
    def code_review(self, code_snippet: str) -> str:
        if not self.budget.can_call(code_snippet):
            return "تم تجاوز الميزانية: لا يمكن معالجة هذا الطلب."
        
        prompt = f"راجع هذا الكود واقترح تحسينات:\n{code_snippet}"
        response = cached_llm_call(prompt)
        
        tokens_used = self.budget.count_tokens(prompt) + self.budget.count_tokens(response)
        self.budget.record_usage(tokens_used)
        
        return response

أمثلة الاستخدام

دعنا نوضح كيف يعمل الوكيل المتحكم في الإنفاق عملياً.

المثال 1: مراجعة كود أساسية

احفظ هذا كـ `example_review.py`.

from budget_manager import TokenBudgetManager
from coding_agent import SpendControlledCodingAgent

# التهيئة بميزانية 500 رمز لكل استدعاء وميزانية إجمالية 10,000 رمز
budget = TokenBudgetManager(max_tokens_per_call=500, max_total_tokens=10000)
agent = SpendControlledCodingAgent(budget)

# مقتطف كود بسيط
code = """
def add(a, b):
    return a + b
"""
result = agent.code_review(code)
print("نتيجة المراجعة:", result)
print("إجمالي الرموز المستخدمة حتى الآن:", budget.total_used)

قم بتشغيله:

python example_review.py

يظهر الإخراج المتوقع مراجعة موجزة وعدد الرموز المستخدمة أقل من 500.

المثال 2: مراقبة الإنفاق باستخدام Prometheus

قم بدمج مقاييس الوقت الفعلي للوحات المعلومات.

from prometheus_client import Counter, Histogram, start_http_server

# تعريف المقاييس
TOKEN_COUNT = Counter('llm_tokens_total', 'إجمالي الرموز المستهلكة', ['model'])
REQUEST_DURATION = Histogram('llm_request_duration_seconds', 'مدة استدعاءات LLM')

start_http_server(8000)  # عرض المقاييس على localhost:8000

@REQUEST_DURATION.time()
def monitored_llm_call(prompt: str):
    response = cached_llm_call(prompt)
    tokens = budget.count_tokens(prompt) + budget.count_tokens(response)
    TOKEN_COUNT.labels(model="gpt-4").inc(tokens)
    return response

الوصول إلى المقاييس باستخدام:

curl http://localhost:8000/metrics

المثال 3: المعالجة المجمعة مع حدود الميزانية

قم بمعالجة قائمة من ملفات الأكواد دون تجاوز الميزانية.

code_files = ["file1.py", "file2.py", "file3.py"]
for file in code_files:
    with open(file, 'r') as f:
        code = f.read()
    if budget.can_call(code):
        result = agent.code_review(code)
        print(f"تمت مراجعة {file}: {result}")
    else:
        print(f"تم تخطي {file}: تم الوصول إلى حد الميزانية")
        break

كيف يضمن النظام إنفاقاً قابلاً للتوقع

تحقق البنية التحتية أعلاه قابلية توقع التكاليف من خلال ثلاث آليات:

1. **فرض ميزانية الرموز**: يرفض `TokenBudgetManager` الاستدعاءات التي تتجاوز الميزانيات لكل استدعاء أو الإجمالية، مما يمنع التكاليف الجامحة. هذا يعكس الأساليب التي تمت مناقشتها في مدونة LangChain، حيث يتم بناء وكلاء واعين بالرموز لتجنب النفقات غير المتوقعة.

2. **التخزين المؤقت للاستجابات**: من خلال تخزين الاستفسارات المتطابقة مؤقتاً في Redis، نلغي استدعاءات API المكررة - وهي تقنية تم تسليط الضوء عليها في منشورات مدونة Microsoft AI حول تقليل زمن الاستجابة والتكاليف في أنظمة AI الإنتاجية.

3. **المراقبة في الوقت الفعلي**: توفر مقاييس Prometheus رؤية لأنماط استهلاك الرموز. أكدت أخبار OpenAI على أهمية المراقبة لإدارة تكاليف LLM على نطاق واسع.

التكوين المتقدم

للنشر في الإنتاج، ضع في اعتبارك هذه التحسينات:

ضبط الميزانية الديناميكي

اضبط الميزانيات بناءً على تعقيد المهمة باستخدام استرشادي.

def estimate_complexity(code: str) -> int:
    # استرشادي بسيط: المزيد من الأسطر = المزيد من الرموز المطلوبة
    return min(2000, len(code.splitlines()) * 50)

class AdaptiveBudgetManager(TokenBudgetManager):
    def can_call(self, code: str) -> bool:
        needed = estimate_complexity(code)
        return needed <= self.max_total_tokens - self.total_used

تنبيهات التكاليف عبر Webhooks

أرسل تنبيهات عند تجاوز حدود الميزانية.

import requests

def send_alert(message: str):
    requests.post("https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK", json={"text": message})

if budget.total_used >= budget.max_total_tokens * 0.9:
    send_alert(f"إنفاق الوكيل عند 90% من الميزانية: تم استخدام {budget.total_used} رمز")

الخلاصة

جعل إنفاق وكيل البرمجة قابلاً للتوقع لا يتعلق فقط بتحديد الرموز - بل يتعلق بتصميم نظام يوازن بين التكلفة والأداء وسهولة الاستخدام. من خلال تنفيذ مدير ميزانية الرموز، وطبقة تخزين مؤقت، ومراقبة في الوقت الفعلي، يمكنك نشر وكلاء البرمجة بثقة، مع العلم أن التكاليف ستبقى ضمن الحدود. النهج الموضح هنا، بالاستفادة من ممارسات الصناعة من LangChain وOpenAI وMicrosoft، هو نهج معياري وقابل للتوسيع، مما يسمح لك بتكييفه مع احتياجاتك الخاصة. ابدأ بخطوات التركيب الأساسية، ثم كرر العملية مع الميزات المتقدمة مع نمو استخدامك. باستخدام هذه الأدوات، يصبح الإنفاق غير المتوقع شيئاً من الماضي.