מערכת עיבוד בקשות אוטונומית מבוססת AI במפתח מלא

אנו מפתחים מערכות עיבוד בקשות AI אוטונומיות. מדובר באורכיסטרטור AI שמקבל בקשות נכנסות מערוצים שונים: דוא"ל, טפסים, API, מסנג'רים. המערכת מסווגת אותן, מחלצת נתונים, מבצעת לוגיקת עיבוד ומחזירה תשובה. או יוצרת משימות במערכות עסקיות — הכל ללא מעורבות מפעיל במקרים טיפוסיים.

בניגוד לצ'אטבוט פשוט או סוכן עם כלי יחיד, המערכת שלנו כוללת מחזור מלא: קליטה → הבנה → העשרת נתונים → ביצוע → התראה → ניטור. יישמנו עשרות פרויקטים כאלה, ובמאמר זה נפרק את הארכיטקטורה באמצעות דוגמה אמיתית.

כיצד פועל סיווג הבקשות?

הבקשה הנכנסת עוברת דרך גרף מצבים של LangGraph. הצומת הראשון הוא מסווג המבוסס על GPT-4o עם מודל Pydantic. הוא קובע את סוג הבקשה (תמיכה טכנית, חיוב, הזמנה חדשה, סטטוס, תלונה, החזר כספי), דחיפות, רמת ביטחון והצורך בהסלמה אנושית. אם רמת הביטחון נמוכה מ-0.6 או שהבקשה מכילה טריגרים (איומים משפטיים, החזרים מעל סף מסוים, אזכור נזקים) — הבקשה מועברת למפעיל. זהו הניסיון שלנו, המאושר על ידי מאות פרויקטים.

ארכיטקטורת המערכת

ערוצי קלט

• webhook (מפענח דוא"ל)
• REST API
• בוט Telegram/WhatsApp
• טופס אינטרנט

ליבת העיבוד

גרף מצבים של LangGraph עם סיווג, מבצעים ואגרגטור.

ערוצי פלט

• REST API של מערכות חיצוניות (CRM, ERP, Service Desk)
• התראות דוא"ל/push
• תור משימות (Celery/Redis)

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict, Annotated, Optional
from datetime import datetime
import operator

class RequestState(TypedDict):
    # Входящий запрос
    raw_content: str
    channel: str  # "email", "api", "telegram", "form"
    sender_id: str
    received_at: datetime

    # Классификация
    request_type: Optional[str]  # "support", "order", "complaint", "inquiry", "refund"
    urgency: Optional[str]  # "critical", "high", "normal", "low"
    confidence: Optional[float]

    # Обогащение
    user_profile: Optional[dict]
    related_entities: Optional[list]  # Связанные заказы, договоры, тикеты

    # Обработка
    action_plan: Optional[list[dict]]
    executed_actions: Annotated[list, operator.add]
    requires_human: bool
    human_reason: Optional[str]

    # Результат
    response_draft: Optional[str]
    outcome: Optional[str]
    processing_time_ms: Optional[int]

from langchain_openai import ChatOpenAI
from pydantic import BaseModel
from typing import Literal

class RequestClassification(BaseModel):
    request_type: Literal["support_technical", "support_billing", "order_new", "order_status", "complaint", "refund_request", "general_inquiry"]
    urgency: Literal["critical", "high", "normal", "low"]
    confidence: float
    extracted_entities: dict
    requires_human: bool
    human_reason: Optional[str] = None
    summary: str

llm = ChatOpenAI(model="gpt-4o", temperature=0)

def classify_request(state: RequestState) -> RequestState:
    result = llm.with_structured_output(RequestClassification).invoke(
        f"""Классифицируй входящий запрос.
Канал: {state['channel']}
Запрос: {state['raw_content']}
Передай человеку если:
- Юридические угрозы или упоминание судебных разбирательств
- Запрос на возврат суммы > $450–650
- Упоминание о физическом ущербе
- Эмоционально заряженный отзыв с публичными угрозами"""
    )
    return {
        **state,
        "request_type": result.request_type,
        "urgency": result.urgency,
        "confidence": result.confidence,
        "requires_human": result.requires_human,
        "human_reason": result.human_reason,
    }

def plan_actions(state: RequestState) -> RequestState:
    """Агент составляет план действий на основе типа запроса"""
    action_templates = {
        "order_status": [
            {"action": "query_order_db", "params": {"order_id": "{extracted_order_id}"}},
            {"action": "generate_status_response", "params": {}},
            {"action": "send_response", "params": {}},
        ],
        "refund_request": [
            {"action": "verify_refund_eligibility", "params": {}},
            {"action": "create_refund_ticket", "params": {}},
            {"action": "notify_finance_team", "params": {}},
            {"action": "send_confirmation", "params": {}},
        ],
        "support_technical": [
            {"action": "search_knowledge_base", "params": {}},
            {"action": "generate_solution", "params": {}},
            {"action": "create_ticket_if_unsolved", "params": {}},
            {"action": "send_response", "params": {}},
        ],
    }
    base_plan = action_templates.get(state["request_type"], [
        {"action": "generate_generic_response", "params": {}},
        {"action": "create_manual_review_task", "params": {}},
    ])
    return {**state, "action_plan": base_plan}

def route_after_classification(state: RequestState) -> str:
    if state["requires_human"]:
        return "escalate_to_human"
    if state["confidence"] < 0.6:
        return "escalate_to_human"
    return "enrich"

def route_after_enrichment(state: RequestState) -> str:
    if state.get("user_profile", {}).get("tier") == "vip" and state["urgency"] in ("high", "critical"):
        return "plan_premium"
    return "plan"

graph = StateGraph(RequestState)
graph.add_node("classify", classify_request)
graph.add_node("enrich", enrich_request)
graph.add_node("plan", plan_actions)
graph.add_node("plan_premium", plan_premium_actions)
graph.add_node("execute", execute_actions)
graph.add_node("generate_response", generate_final_response)
graph.add_node("escalate_to_human", create_human_task)
graph.add_node("send_response", send_response_to_channel)
graph.set_entry_point("classify")
graph.add_conditional_edges("classify", route_after_classification)
graph.add_conditional_edges("enrich", route_after_enrichment)
graph.add_edge("plan", "execute")
graph.add_edge("plan_premium", "execute")
graph.add_edge("execute", "generate_response")
graph.add_edge("generate_response", "send_response")
graph.add_edge("send_response", END)
graph.add_edge("escalate_to_human", END)
processor = graph.compile(checkpointer=PostgresSaver(conn))

מדוע המערכת פועלת ללא מפעיל?

ההבדל המרכזי הוא היכולת לבצע פעולות במערכות עסקיות: יצירת הזמנות, בדיקת סטטוסים, עיבוד החזרים, שליחת התראות. כל פעולה היא מודול מוכן שהמערכת מפעילה לפי התוכנית. מתכנן הפעולות יוצר רצף צעדים בהתבסס על סוג הבקשה והקשר המשתמש. אם התוכנית מבוצעת בהצלחה, התשובה נשלחת אוטומטית. אחרת, המערכת מסלימה את המשימה למפעיל עם יומן שגיאות מפורט.

מקרה מעשי: קמעונאית מקוונת, 2500 בקשות ביום

לפני היישום: זמן תגובה ראשונה ממוצע של 4.2 שעות, 12 מפעילים בשלוש משמרות, 60% מהזמן הושקע בשאלות סטטוס סטנדרטיות.

לאחר היישום:

• עיבוד אוטונומי ללא מעורבות מפעיל: 74%
• זמן תגובה ראשונה ממוצע: מ-4.2 שעות ל-2.1 דקות (פי 120 מהר יותר)
• משמרת לילה: צומצמה מ-4 ל-1 מפעיל (ניטור הסלמות)
• דיוק תשובות (מדגם של 500 בקשות): 94.1%
• הסלמות שגויות: 8.3%
• סגירה אוטומטית שגויה: 2.1%

מה כלול בעבודה

• ארכיטקטורה ועיצוב: מידול גרף המצבים, הגדרת סוגי בקשות, תרחישי עיבוד.
• פיתוח מסווג: הנדסת prompts, כוונון עדין של GPT-4o במידת הצורך, בדיקות על נתונים היסטוריים.
• אינטגרציית ערוצים: webhook, API, מסנג'רים, טפסי אינטרנט.
• מבצעי פעולות: חיבור ל-CRM, ERP, Service Desk, תכנות לפעולות סטנדרטיות.
• מערכת ניטור: מדדי Prometheus, לוחות מחוונים של Grafana, התראות SLA.
• תיעוד: תיאור גרף, API, הוראות למפעילים.
• הכשרת צוות: סדנה על כוונון עדין של מודלים וניהול.
• תמיכה בהשקה: שבועיים של סיוע לאחר הפריסה.

כיצד אנו עושים זאת: תוכנית שלב אחר שלב

1. אנליטיקה (1–2 שבועות): איסוף לוגים, זיהוי בקשות טיפוסיות, הגדרת קריטריוני הסלמה.
2. עיצוב גרף (1–2 שבועות): יצירת StateGraph, הגדרת צמתים וקשתות.
3. פיתוח מסווג (2–3 שבועות): אימון מודל, בדיקה על מדגם.
4. יישום מבצעים (2–4 שבועות): תכנות לכל סוג בקשה.
5. אינטגרציית ערוצים (1–2 שבועות): חיבור דוא"ל, API, מסנג'רים.
6. בדיקות וכיול (שבועיים): הרצה על נתונים אמיתיים, התאמת ספים.
7. פריסה וניטור: פריסה על Kubernetes, הגדרת התראות.

לוח זמנים

• ארכיטקטורת מערכת וגרף: 1–2 שבועות
• מסווג + העשרת נתונים: 2–3 שבועות
• מבצעים לכל סוג בקשה: 2–4 שבועות
• אינטגרציית ערוצים (דוא"ל, מסנג'רים): 1–2 שבועות
• כיול והשקה לייצור: שבועיים
• סה"כ: 8–13 שבועות

נעריך את הפרויקט שלכם – פשוט צרו קשר. אנו מבטיחים שקיפות בכל שלב ומספקים תיעוד מלא. מהנדסים מוסמכים עם ניסיון של 10+ שנים יישמו את המערכת במפתח מלא. להערכה ראשונית של זרימת הבקשות שלכם, הזמינו ביקורת – נקבע את פוטנציאל האוטומציה ואת לוח הזמנים ליישום.