mirror of
https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools.git
synced 2026-06-18 07:19:35 +00:00
380 lines
14 KiB
Python
380 lines
14 KiB
Python
"""
|
|
Dealix Self-Improving Intelligence Engine (SIIE)
|
|
================================================
|
|
النظام يتعلم من كل تفاعل ويحسن نفسه تلقائياً:
|
|
- Self-Improvement: يحسن استراتيجياته بناءً على النتائج
|
|
- Self-Healing: يكتشف المشاكل ويصلحها تلقائياً
|
|
- Self-Expansion: يحدد فرص جديدة وينمو ذاتياً
|
|
- Self-Evolution: يطور قدراته مع الوقت
|
|
"""
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import time
|
|
from datetime import datetime, timedelta
|
|
from typing import Optional, Any
|
|
from collections import defaultdict
|
|
|
|
from groq import AsyncGroq
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class PerformanceTracker:
|
|
"""Tracks all system performance metrics for self-improvement."""
|
|
|
|
def __init__(self):
|
|
self.metrics = defaultdict(list)
|
|
self.strategy_scores = {}
|
|
self.best_practices = []
|
|
|
|
def record(self, category: str, value: float, metadata: dict = None):
|
|
self.metrics[category].append({
|
|
"value": value,
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"metadata": metadata or {}
|
|
})
|
|
|
|
def get_average(self, category: str, last_n: int = 10) -> float:
|
|
values = [m["value"] for m in self.metrics[category][-last_n:]]
|
|
return sum(values) / len(values) if values else 0
|
|
|
|
def get_trend(self, category: str) -> str:
|
|
vals = [m["value"] for m in self.metrics[category][-5:]]
|
|
if len(vals) < 2:
|
|
return "insufficient_data"
|
|
return "improving" if vals[-1] > vals[0] else "declining"
|
|
|
|
def identify_best_strategy(self) -> dict:
|
|
"""Find what's working best."""
|
|
analysis = {}
|
|
for category, records in self.metrics.items():
|
|
if len(records) >= 3:
|
|
analysis[category] = {
|
|
"average": self.get_average(category),
|
|
"trend": self.get_trend(category),
|
|
"best_value": max(r["value"] for r in records),
|
|
"worst_value": min(r["value"] for r in records),
|
|
}
|
|
return analysis
|
|
|
|
|
|
class SelfHealingMonitor:
|
|
"""Monitors system health and auto-repairs issues."""
|
|
|
|
def __init__(self):
|
|
self.health_checks = {}
|
|
self.failure_counts = defaultdict(int)
|
|
self.auto_fixes_applied = []
|
|
|
|
def check_component(self, name: str, status: bool, error: str = None):
|
|
self.health_checks[name] = {
|
|
"status": "healthy" if status else "unhealthy",
|
|
"last_check": datetime.utcnow().isoformat(),
|
|
"error": error
|
|
}
|
|
if not status:
|
|
self.failure_counts[name] += 1
|
|
|
|
def needs_healing(self, component: str) -> bool:
|
|
return self.failure_counts[component] >= 3
|
|
|
|
def apply_fix(self, component: str, fix: str):
|
|
self.auto_fixes_applied.append({
|
|
"component": component,
|
|
"fix": fix,
|
|
"timestamp": datetime.utcnow().isoformat()
|
|
})
|
|
self.failure_counts[component] = 0
|
|
|
|
def get_system_health(self) -> dict:
|
|
total = len(self.health_checks)
|
|
healthy = sum(1 for h in self.health_checks.values() if h["status"] == "healthy")
|
|
return {
|
|
"overall": "healthy" if healthy == total else "degraded" if healthy > total / 2 else "critical",
|
|
"score": (healthy / total * 100) if total > 0 else 100,
|
|
"components": self.health_checks,
|
|
"auto_fixes_applied": len(self.auto_fixes_applied)
|
|
}
|
|
|
|
|
|
class StrategicIntelligence:
|
|
"""Strategic planning and market expansion engine."""
|
|
|
|
def __init__(self, groq_client: AsyncGroq):
|
|
self.client = groq_client
|
|
|
|
async def analyze_market_opportunity(self, performance_data: dict) -> dict:
|
|
prompt = f"""أنت مستشار استراتيجي لديليكس (نظام ذكاء اصطناعي للمبيعات السعودي).
|
|
|
|
بيانات الأداء الحالية:
|
|
{json.dumps(performance_data, ensure_ascii=False, indent=2)}
|
|
|
|
قدّم تحليلاً استراتيجياً:
|
|
{{
|
|
"market_opportunities": [
|
|
{{
|
|
"opportunity": "الفرصة",
|
|
"market_size": "حجم السوق",
|
|
"entry_strategy": "استراتيجية الدخول",
|
|
"time_to_value": "وقت تحقيق القيمة",
|
|
"priority": "high/medium/low"
|
|
}}
|
|
],
|
|
"competitive_advantages": ["ميزة تنافسية 1", "ميزة 2"],
|
|
"recommended_expansions": [
|
|
{{
|
|
"sector": "القطاع",
|
|
"rationale": "السبب",
|
|
"required_resources": "الموارد المطلوبة"
|
|
}}
|
|
],
|
|
"revenue_optimization": {{
|
|
"current_gaps": ["فجوة في الإيرادات"],
|
|
"quick_wins": ["ربح سريع"],
|
|
"strategic_moves": ["خطوة استراتيجية"]
|
|
}},
|
|
"self_improvement_priorities": [
|
|
"ما يجب تحسينه أولاً في النظام"
|
|
]
|
|
}}"""
|
|
|
|
response = await self.client.chat.completions.create(
|
|
model="llama-3.3-70b-versatile",
|
|
messages=[{"role": "user", "content": prompt}],
|
|
temperature=0.3,
|
|
max_tokens=2000,
|
|
response_format={"type": "json_object"}
|
|
)
|
|
return json.loads(response.choices[0].message.content)
|
|
|
|
async def generate_growth_plan(self, current_metrics: dict) -> dict:
|
|
prompt = f"""بناءً على مقاييس ديليكس الحالية:
|
|
{json.dumps(current_metrics, ensure_ascii=False)}
|
|
|
|
اصنع خطة نمو 90 يوم:
|
|
{{
|
|
"q90_goal": "الهدف",
|
|
"monthly_milestones": [
|
|
{{"month": 1, "goal": "...", "kpis": {{}}}},
|
|
{{"month": 2, "goal": "...", "kpis": {{}}}},
|
|
{{"month": 3, "goal": "...", "kpis": {{}}}}
|
|
],
|
|
"expansion_sectors": ["قطاع جديد"],
|
|
"automation_opportunities": ["مهمة يمكن أتمتتها"],
|
|
"financial_projections": {{
|
|
"month_1_revenue": 0,
|
|
"month_2_revenue": 0,
|
|
"month_3_revenue": 0
|
|
}}
|
|
}}"""
|
|
|
|
response = await self.client.chat.completions.create(
|
|
model="llama-3.3-70b-versatile",
|
|
messages=[{"role": "user", "content": prompt}],
|
|
temperature=0.2,
|
|
max_tokens=1500,
|
|
response_format={"type": "json_object"}
|
|
)
|
|
return json.loads(response.choices[0].message.content)
|
|
|
|
|
|
class FinancialIntelligence:
|
|
"""Financial analytics, forecasting, and optimization."""
|
|
|
|
def __init__(self, groq_client: AsyncGroq):
|
|
self.client = groq_client
|
|
|
|
async def generate_financial_forecast(self, pipeline_data: dict) -> dict:
|
|
prompt = f"""أنت محلل مالي لديليكس. بناءً على بيانات pipeline:
|
|
{json.dumps(pipeline_data, ensure_ascii=False)}
|
|
|
|
قدّم تحليلاً مالياً:
|
|
{{
|
|
"arr_projection": "Annual Recurring Revenue المتوقع",
|
|
"pipeline_value": "قيمة pipeline الحالية",
|
|
"conversion_rate": "معدل التحويل المتوقع %",
|
|
"average_deal_size": "متوسط حجم الصفقة بالريال",
|
|
"payback_period": "فترة استرداد التكلفة",
|
|
"ltv_cac_ratio": "نسبة LTV:CAC",
|
|
"monthly_targets": {{
|
|
"leads": "عدد الـ leads المطلوبة",
|
|
"meetings": "عدد الاجتماعات",
|
|
"deals": "عدد الصفقات",
|
|
"revenue": "الإيراد المستهدف"
|
|
}},
|
|
"pricing_optimization": {{
|
|
"current_gap": "الفجوة في التسعير",
|
|
"recommended_price_range": "النطاق السعري المقترح",
|
|
"value_justification": "مبرر القيمة"
|
|
}},
|
|
"risk_assessment": {{
|
|
"risks": ["خطر 1"],
|
|
"mitigation": ["حل للخطر"]
|
|
}}
|
|
}}"""
|
|
|
|
response = await self.client.chat.completions.create(
|
|
model="llama-3.3-70b-versatile",
|
|
messages=[{"role": "user", "content": prompt}],
|
|
temperature=0.1,
|
|
max_tokens=1500,
|
|
response_format={"type": "json_object"}
|
|
)
|
|
return json.loads(response.choices[0].message.content)
|
|
|
|
|
|
class SelfImprovementEngine:
|
|
"""
|
|
The core self-improvement loop.
|
|
Analyzes performance → identifies gaps → generates improvements → applies them.
|
|
"""
|
|
|
|
def __init__(self, groq_client: AsyncGroq):
|
|
self.client = groq_client
|
|
self.tracker = PerformanceTracker()
|
|
self.improvements_log = []
|
|
|
|
async def analyze_and_improve(self, system_data: dict) -> dict:
|
|
"""Main self-improvement cycle."""
|
|
|
|
performance_analysis = self.tracker.identify_best_strategy()
|
|
|
|
prompt = f"""أنت نظام تحسين ذاتي لديليكس. حلّل هذه البيانات وحدد كيف يتحسن النظام:
|
|
|
|
بيانات النظام الحالية:
|
|
{json.dumps(system_data, ensure_ascii=False, indent=2)}
|
|
|
|
تحليل الأداء التاريخي:
|
|
{json.dumps(performance_analysis, ensure_ascii=False, indent=2)}
|
|
|
|
قدّم خطة التحسين الذاتي:
|
|
{{
|
|
"performance_diagnosis": "تشخيص الأداء الحالي",
|
|
"weakest_areas": ["المجال الأضعف 1", "المجال 2"],
|
|
"strongest_areas": ["أفضل مجال 1"],
|
|
"improvement_actions": [
|
|
{{
|
|
"area": "المجال",
|
|
"current_score": 0,
|
|
"target_score": 0,
|
|
"action": "الإجراء",
|
|
"expected_impact": "high/medium/low",
|
|
"auto_applicable": true
|
|
}}
|
|
],
|
|
"prompt_optimizations": [
|
|
{{
|
|
"agent": "اسم الوكيل",
|
|
"current_issue": "المشكلة الحالية",
|
|
"suggested_improvement": "التحسين المقترح"
|
|
}}
|
|
],
|
|
"new_capabilities_to_acquire": [
|
|
"قدرة جديدة يجب إضافتها للنظام"
|
|
],
|
|
"estimated_improvement": "نسبة التحسن المتوقعة %"
|
|
}}"""
|
|
|
|
response = await self.client.chat.completions.create(
|
|
model="llama-3.3-70b-versatile",
|
|
messages=[{"role": "user", "content": prompt}],
|
|
temperature=0.2,
|
|
max_tokens=2000,
|
|
response_format={"type": "json_object"}
|
|
)
|
|
|
|
improvement_plan = json.loads(response.choices[0].message.content)
|
|
improvement_plan["generated_at"] = datetime.utcnow().isoformat()
|
|
self.improvements_log.append(improvement_plan)
|
|
|
|
return improvement_plan
|
|
|
|
def record_interaction_outcome(self, interaction_type: str, success: bool, details: dict = None):
|
|
"""Record every interaction outcome for learning."""
|
|
score = 100 if success else 0
|
|
self.tracker.record(interaction_type, score, details)
|
|
|
|
|
|
class DealixAutonomousCore:
|
|
"""
|
|
The complete autonomous intelligence core of Dealix.
|
|
Self-improving, self-healing, self-expanding system.
|
|
"""
|
|
|
|
def __init__(self, groq_api_key: str):
|
|
self.client = AsyncGroq(api_key=groq_api_key)
|
|
self.improver = SelfImprovementEngine(self.client)
|
|
self.strategic = StrategicIntelligence(self.client)
|
|
self.financial = FinancialIntelligence(self.client)
|
|
self.healer = SelfHealingMonitor()
|
|
self._running = False
|
|
self._cycle_count = 0
|
|
|
|
async def run_autonomous_cycle(self):
|
|
"""The main autonomous improvement cycle — runs continuously."""
|
|
self._running = True
|
|
logger.info("🚀 Dealix Autonomous Core activated")
|
|
|
|
while self._running:
|
|
self._cycle_count += 1
|
|
try:
|
|
# Collect system state
|
|
system_data = {
|
|
"cycle": self._cycle_count,
|
|
"timestamp": datetime.utcnow().isoformat(),
|
|
"health": self.healer.get_system_health(),
|
|
"performance_trends": self.improver.tracker.identify_best_strategy()
|
|
}
|
|
|
|
# Every 10 cycles: run full improvement analysis
|
|
if self._cycle_count % 10 == 0:
|
|
improvement = await self.improver.analyze_and_improve(system_data)
|
|
logger.info(f"🔄 Self-improvement cycle: {improvement.get('estimated_improvement')} improvement")
|
|
|
|
# Every 50 cycles: strategic expansion analysis
|
|
if self._cycle_count % 50 == 0:
|
|
strategy = await self.strategic.analyze_market_opportunity(system_data)
|
|
logger.info(f"📊 Strategic analysis completed")
|
|
|
|
await asyncio.sleep(300) # 5 minute cycles
|
|
|
|
except asyncio.CancelledError:
|
|
break
|
|
except Exception as e:
|
|
logger.error(f"Autonomous cycle error: {e}")
|
|
self.healer.check_component("autonomous_core", False, str(e))
|
|
await asyncio.sleep(60)
|
|
|
|
async def get_full_intelligence_report(self) -> dict:
|
|
"""Get a comprehensive system intelligence report."""
|
|
system_data = {
|
|
"cycle_count": self._cycle_count,
|
|
"health": self.healer.get_system_health(),
|
|
"performance": self.improver.tracker.identify_best_strategy(),
|
|
"improvements_applied": len(self.improver.improvements_log),
|
|
"auto_fixes": len(self.healer.auto_fixes_applied)
|
|
}
|
|
|
|
financial = await self.financial.generate_financial_forecast(system_data)
|
|
strategy = await self.strategic.analyze_market_opportunity(system_data)
|
|
|
|
return {
|
|
"system_state": system_data,
|
|
"financial_intelligence": financial,
|
|
"strategic_intelligence": strategy,
|
|
"autonomous_improvements": self.improver.improvements_log[-3:] if self.improver.improvements_log else [],
|
|
"generated_at": datetime.utcnow().isoformat()
|
|
}
|
|
|
|
|
|
# ── Global Singleton ─────────────────────────────────────────
|
|
_core: Optional[DealixAutonomousCore] = None
|
|
|
|
|
|
def get_autonomous_core(api_key: str) -> DealixAutonomousCore:
|
|
global _core
|
|
if _core is None:
|
|
_core = DealixAutonomousCore(api_key)
|
|
return _core
|