# AI агенти и малки езикови модели: Пълно ръководство ## Въведение В този урок ще разгледаме AI агенти и малки езикови модели (SLMs) и техните усъвършенствани стратегии за внедряване в среди за edge computing. Ще обхванем основните концепции на агентния AI, техники за оптимизация на SLM, практически стратегии за внедряване на устройства с ограничени ресурси и Microsoft Agent Framework за изграждане на готови за производство агентни системи. Пейзажът на изкуствения интелект преживява парадигматична промяна през 2025 г. Докато 2023 беше годината на чатботовете, а 2024 отбеляза бум на копилотите, 2025 принадлежи на AI агентите — интелигентни системи, които мислят, разсъждават, планират, използват инструменти и изпълняват задачи с минимален човешки принос, все повече захранвани от ефективни малки езикови модели. Microsoft Agent Framework се очертава като водещо решение за изграждане на тези интелигентни системи с офлайн възможности за edge computing. ## Цели на обучението До края на този урок ще можете: - 🤖 Да разберете основните концепции на AI агентите и агентните системи - 🔬 Да идентифицирате предимствата на малките езикови модели спрямо големите езикови модели в агентни приложения - 🚀 Да научите усъвършенствани стратегии за внедряване на SLM в среди за edge computing - 📱 Да внедрите практически агенти, захранвани от SLM, за реални приложения - 🏗️ Да изградите готови за производство агенти с Microsoft Agent Framework - 🌐 Да внедрите офлайн агенти за edge computing с интеграция на локални LLM и SLM - 🔧 Да интегрирате Microsoft Agent Framework с Foundry Local за edge внедряване ## Разбиране на AI агентите: Основи и класификации ### Определение и основни концепции Изкуственият интелект (AI) агент се отнася до система или програма, която е способна автономно да изпълнява задачи от името на потребител или друга система, като проектира своя работен процес и използва наличните инструменти. За разлика от традиционния AI, който просто отговаря на вашите въпроси, агентът може да действа независимо за постигане на цели. ### Рамка за класификация на агентите Разбирането на границите на агентите помага при избора на подходящи типове агенти за различни компютърни сценарии: - **🔬 Прости рефлексни агенти**: Системи, базирани на правила, които реагират на непосредствени възприятия (термостати, основна автоматизация) - **📱 Агенти, базирани на модел**: Системи, които поддържат вътрешно състояние и памет (роботизирани прахосмукачки, навигационни системи) - **⚖️ Агенти, базирани на цели**: Системи, които планират и изпълняват последователности за постигане на цели (планиране на маршрути, графици за задачи) - **🧠 Учещи агенти**: Адаптивни системи, които подобряват производителността с времето (системи за препоръки, персонализирани асистенти) ### Основни предимства на AI агентите AI агентите предлагат няколко основни предимства, които ги правят идеални за приложения в edge computing: **Оперативна автономия**: Агенти предоставят независимо изпълнение на задачи без постоянен човешки надзор, което ги прави идеални за приложения в реално време. Те изискват минимален надзор, като същевременно поддържат адаптивно поведение, което позволява внедряване на устройства с ограничени ресурси с намалени оперативни разходи. **Гъвкавост на внедряването**: Тези системи позволяват AI възможности на устройството без изисквания за интернет свързаност, подобряват поверителността и сигурността чрез локална обработка, могат да бъдат персонализирани за специфични за домейна приложения и са подходящи за различни среди за edge computing. **Икономическа ефективност**: Агентните системи предлагат икономически ефективно внедряване в сравнение с решения, базирани на облак, с намалени оперативни разходи и по-ниски изисквания за честотна лента за edge приложения. ## Усъвършенствани стратегии за малки езикови модели ### Основи на SLM (малки езикови модели) Малък езиков модел (SLM) е езиков модел, който може да се побере на обикновено потребителско електронно устройство и да извършва изводи с достатъчно ниска латентност, за да бъде практичен при обслужване на агентни заявки на един потребител. На практика, SLM обикновено са модели с по-малко от 10 милиарда параметри. **Функции за откриване на формати**: SLM предлагат усъвършенствана поддръжка за различни нива на квантизация, съвместимост между платформи, оптимизация за реално време и възможности за edge внедряване. Потребителите могат да се възползват от подобрена поверителност чрез локална обработка и поддръжка на WebGPU за внедряване в браузъра. **Колекции от нива на квантизация**: Популярни SLM формати включват Q4_K_M за балансирана компресия в мобилни приложения, Q5_K_S серия за внедряване, фокусирано върху качеството, Q8_0 за почти оригинална прецизност на мощни edge устройства и експериментални формати като Q2_K за сценарии с ултра-ниски ресурси. ### GGUF (Общ GGML универсален формат) за внедряване на SLM GGUF служи като основен формат за внедряване на квантизирани SLM на CPU и edge устройства, специално оптимизиран за агентни приложения: **Функции, оптимизирани за агенти**: Форматът предоставя изчерпателни ресурси за конвертиране и внедряване на SLM с подобрена поддръжка за извикване на инструменти, генериране на структурирани изходи и многократни разговори. Съвместимостта между платформи гарантира последователно поведение на агентите на различни edge устройства. **Оптимизация на производителността**: GGUF позволява ефективно използване на паметта за работни потоци на агентите, поддържа динамично зареждане на модели за многосистемни агенти и предоставя оптимизирани изводи за взаимодействия в реално време. ### Edge-оптимизирани SLM рамки #### Оптимизация на Llama.cpp за агенти Llama.cpp предоставя авангардни техники за квантизация, специално оптимизирани за внедряване на агентни SLM: **Квантизация, специфична за агенти**: Рамката поддържа Q4_0 (оптимално за мобилно внедряване на агенти с 75% намаление на размера), Q5_1 (балансирано качество-компресия за edge изводи на агенти) и Q8_0 (почти оригинално качество за производствени агентни системи). Усъвършенстваните формати позволяват ултра-компресирани агенти за екстремни edge сценарии. **Ползи от внедряването**: Оптимизираните за CPU изводи със SIMD ускорение предоставят изпълнение на агенти с ефективно използване на паметта. Съвместимостта между платформи на x86, ARM и Apple Silicon архитектури позволява универсални възможности за внедряване на агенти. #### Apple MLX рамка за SLM агенти Apple MLX предоставя родна оптимизация, специално проектирана за агенти, захранвани от SLM, на устройства с Apple Silicon: **Оптимизация за агенти на Apple Silicon**: Рамката използва унифицирана архитектура на паметта с интеграция на Metal Performance Shaders, автоматична смесена прецизност за изводи на агенти и оптимизирана честотна лента на паметта за многосистемни агенти. SLM агентите показват изключителна производителност на чиповете от серията M. **Функции за разработка**: Поддръжка на Python и Swift API с оптимизации, специфични за агенти, автоматична диференциация за обучение на агенти и безпроблемна интеграция с инструменти за разработка на Apple предоставят изчерпателни среди за разработка на агенти. #### ONNX Runtime за агенти с кръстосана платформа ONNX Runtime предоставя универсален изводен двигател, който позволява на SLM агентите да работят последователно на различни хардуерни платформи и операционни системи: **Универсално внедряване**: ONNX Runtime гарантира последователно поведение на SLM агентите на платформи като Windows, Linux, macOS, iOS и Android. Тази съвместимост между платформи позволява на разработчиците да пишат веднъж и да внедряват навсякъде, значително намалявайки разходите за разработка и поддръжка за многоплатформени приложения. **Опции за хардуерно ускорение**: Рамката предоставя оптимизирани изпълнителни доставчици за различни хардуерни конфигурации, включително CPU (Intel, AMD, ARM), GPU (NVIDIA CUDA, AMD ROCm) и специализирани ускорители (Intel VPU, Qualcomm NPU). SLM агентите могат автоматично да използват най-добрия наличен хардуер без промени в кода. **Функции, готови за производство**: ONNX Runtime предлага функции от корпоративен клас, необходими за внедряване на агенти в производство, включително оптимизация на графики за по-бързи изводи, управление на паметта за среди с ограничени ресурси и изчерпателни инструменти за профилиране за анализ на производителността. Рамката поддържа както Python, така и C++ API за гъвкава интеграция. ## SLM срещу LLM в агентни системи: Усъвършенствано сравнение ### Предимства на SLM в агентни приложения **Оперативна ефективност**: SLM предоставят 10-30× намаление на разходите в сравнение с LLM за агентни задачи, позволявайки отговори на агенти в реално време в мащаб. Те предлагат по-бързи времена за изводи поради намалена изчислителна сложност, което ги прави идеални за интерактивни агентни приложения. **Възможности за edge внедряване**: SLM позволяват изпълнение на агенти на устройството без зависимост от интернет, подобрена поверителност чрез локална обработка и персонализация за специфични за домейна агентни приложения, подходящи за различни среди за edge computing. **Оптимизация, специфична за агенти**: SLM се отличават при извикване на инструменти, генериране на структурирани изходи и рутинни работни потоци за вземане на решения, които съставляват 70-80% от типичните агентни задачи. ### Кога да използвате SLM срещу LLM в агентни системи **Идеални за SLM**: - **Повтарящи се агентни задачи**: Въвеждане на данни, попълване на формуляри, рутинни API извиквания - **Интеграция на инструменти**: Запитвания към бази данни, файлови операции, взаимодействия със системи - **Структурирани работни потоци**: Следване на предварително дефинирани процеси на агенти - **Агенти, специфични за домейна**: Обслужване на клиенти, планиране, основен анализ - **Локална обработка**: Операции на агенти, чувствителни към поверителност **По-добри за LLM**: - **Сложно разсъждение**: Ново решаване на проблеми, стратегическо планиране - **Разговори с отворен край**: Общи чатове, творчески дискусии - **Задачи с обширни знания**: Изследвания, изискващи обширни общи знания - **Нови ситуации**: Работа с напълно нови сценарии за агенти ### Хибридна архитектура на агенти Оптималният подход комбинира SLM и LLM в хетерогенни агентни системи: **Интелигентна оркестрация на агенти**: 1. **SLM като основен**: Обработва 70-80% от рутинните задачи на агенти локално 2. **LLM при нужда**: Пренасочва сложни запитвания към облачни по-големи модели 3. **Специализирани SLM**: Различни малки модели за различни домейни на агенти 4. **Оптимизация на разходите**: Минимизира скъпите LLM извиквания чрез интелигентно пренасочване ## Стратегии за внедряване на SLM агенти в производство ### Foundry Local: Edge AI Runtime от корпоративен клас Foundry Local (https://github.com/microsoft/foundry-local) служи като водещо решение на Microsoft за внедряване на малки езикови модели в производствени edge среди. Той предоставя пълна среда за изпълнение, специално проектирана за агенти, захранвани от SLM, с функции от корпоративен клас и безпроблемни възможности за интеграция. **Основна архитектура и функции**: - **Съвместим API с OpenAI**: Пълна съвместимост с интеграции на OpenAI SDK и Agent Framework - **Автоматична хардуерна оптимизация**: Интелигентен избор на варианти на модели въз основа на наличния хардуер (CUDA GPU, Qualcomm NPU, CPU) - **Управление на модели**: Автоматично изтегляне, кеширане и управление на жизнения цикъл на SLM модели - **Откриване на услуги**: Откриване на услуги без конфигурация за агентни рамки - **Оптимизация на ресурси**: Интелигентно управление на паметта и енергийна ефективност за edge внедряване #### Инсталация и настройка **Инсталация на различни платформи**: ```bash # Windows (recommended) winget install Microsoft.FoundryLocal # macOS brew tap microsoft/foundrylocal brew install foundrylocal # Linux (manual installation) wget https://github.com/microsoft/foundry-local/releases/latest/download/foundry-local-linux.tar.gz tar -xzf foundry-local-linux.tar.gz sudo mv foundry-local /usr/local/bin/ ``` **Бърз старт за разработка на агенти**: ```bash # Start service with automatic model loading foundry model run phi-4-mini # Verify service status and endpoint foundry service status # List available models foundry model ls # Test API endpoint curl http://localhost:/v1/models ``` #### Интеграция на Agent Framework **Интеграция на Foundry Local SDK**: ```python from foundry_local import FoundryLocalManager from microsoft_agent_framework import Agent, Config import openai # Initialize Foundry Local with automatic service management manager = FoundryLocalManager("phi-4-mini") # Configure OpenAI client for local inference client = openai.OpenAI( base_url=manager.endpoint, api_key=manager.api_key # Auto-generated for local usage ) # Create agent with Foundry Local backend agent_config = Config( name="production-agent", model_provider="foundry-local", model_id=manager.get_model_info("phi-4-mini").id, endpoint=manager.endpoint, api_key=manager.api_key ) agent = Agent(config=agent_config) ``` **Автоматичен избор на модели и хардуерна оптимизация**: ```python # Foundry Local automatically selects optimal model variant models_by_use_case = { "lightweight_routing": "qwen2.5-0.5b", # 500MB, ultra-fast "general_conversation": "phi-4-mini", # 2.4GB, balanced "complex_reasoning": "phi-4", # 7GB, high-capability "code_assistance": "qwen2.5-coder-0.5b" # 500MB, code-optimized } # Foundry Local handles hardware detection and quantization for use_case, model_alias in models_by_use_case.items(): manager = FoundryLocalManager(model_alias) print(f"{use_case}: {manager.get_model_info(model_alias).variant_selected}") # Output examples: # lightweight_routing: qwen2.5-0.5b-instruct-q4_k_m.gguf (CPU optimized) # general_conversation: phi-4-mini-instruct-cuda-q5_k_m.gguf (GPU accelerated) ``` #### Модели за производствено внедряване **Настройка на производствен агент**: ```python import asyncio from foundry_local import FoundryLocalManager from microsoft_agent_framework import Agent, Config, Tool class ProductionAgentService: def __init__(self, model_alias="phi-4-mini"): self.foundry = FoundryLocalManager(model_alias) self.agent = self._create_agent() def _create_agent(self): config = Config( name="production-customer-service", model_provider="foundry-local", model_id=self.foundry.get_model_info().id, endpoint=self.foundry.endpoint, api_key=self.foundry.api_key, max_tokens=512, temperature=0.1, timeout=30.0 ) agent = Agent(config=config) # Add production tools @agent.tool def lookup_customer(customer_id: str) -> dict: """Look up customer information from local database.""" return self.local_db.get_customer(customer_id) @agent.tool def create_ticket(issue: str, priority: str = "medium") -> str: """Create a support ticket.""" ticket_id = self.ticketing_system.create(issue, priority) return f"Created ticket {ticket_id}" return agent async def process_request(self, user_input: str) -> str: """Process user request with error handling and monitoring.""" try: response = await self.agent.chat_async(user_input) self.log_interaction(user_input, response, "success") return response except Exception as e: self.log_interaction(user_input, str(e), "error") return "I'm experiencing technical difficulties. Please try again." def health_check(self) -> dict: """Check service health for monitoring.""" return { "foundry_status": self.foundry.health_check(), "model_loaded": self.foundry.is_model_loaded(), "endpoint": self.foundry.endpoint, "memory_usage": self.foundry.get_memory_usage() } # Production usage service = ProductionAgentService("phi-4-mini") response = await service.process_request("I need help with my order #12345") ``` **Оркестрация на многосистемни агенти**: ```python from foundry_local import FoundryLocalManager from microsoft_agent_framework import AgentOrchestrator, Agent, Config class MultiAgentProductionSystem: def __init__(self): self.agents = self._initialize_agents() self.orchestrator = AgentOrchestrator(list(self.agents.values())) def _initialize_agents(self): agents = {} # Lightweight routing agent routing_foundry = FoundryLocalManager("qwen2.5-0.5b") agents["router"] = Agent(Config( name="request-router", model_provider="foundry-local", endpoint=routing_foundry.endpoint, api_key=routing_foundry.api_key, role="Route user requests to appropriate specialized agents" )) # Customer service agent service_foundry = FoundryLocalManager("phi-4-mini") agents["customer_service"] = Agent(Config( name="customer-service", model_provider="foundry-local", endpoint=service_foundry.endpoint, api_key=service_foundry.api_key, role="Handle customer service inquiries and support requests" )) # Technical support agent tech_foundry = FoundryLocalManager("qwen2.5-coder-0.5b") agents["technical"] = Agent(Config( name="technical-support", model_provider="foundry-local", endpoint=tech_foundry.endpoint, api_key=tech_foundry.api_key, role="Provide technical assistance and troubleshooting" )) return agents async def process_request(self, user_input: str) -> str: """Route and process user requests through appropriate agents.""" # Route request to appropriate agent routing_result = await self.agents["router"].chat_async( f"Classify this request and route to customer_service or technical: {user_input}" ) # Determine target agent based on routing target_agent = "customer_service" if "customer" in routing_result.lower() else "technical" # Process with specialized agent response = await self.agents[target_agent].chat_async(user_input) return response # Production deployment system = MultiAgentProductionSystem() response = await system.process_request("My application keeps crashing") ``` #### Функции за корпоративен клас и мониторинг **Мониторинг на здравето и наблюдение**: ```python from foundry_local import FoundryLocalManager import asyncio import logging class FoundryMonitoringService: def __init__(self): self.managers = {} self.metrics = [] def add_model(self, alias: str) -> FoundryLocalManager: """Add a model to monitoring.""" manager = FoundryLocalManager(alias) self.managers[alias] = manager return manager async def collect_metrics(self): """Collect performance metrics from all Foundry Local instances.""" metrics = { "timestamp": time.time(), "models": {} } for alias, manager in self.managers.items(): try: model_metrics = { "status": "healthy" if manager.health_check() else "unhealthy", "memory_usage": manager.get_memory_usage(), "inference_count": manager.get_inference_count(), "average_latency": manager.get_average_latency(), "error_rate": manager.get_error_rate() } metrics["models"][alias] = model_metrics except Exception as e: logging.error(f"Failed to collect metrics for {alias}: {e}") metrics["models"][alias] = {"status": "error", "error": str(e)} self.metrics.append(metrics) return metrics def get_health_status(self) -> dict: """Get overall system health status.""" healthy_models = 0 total_models = len(self.managers) for alias, manager in self.managers.items(): if manager.health_check(): healthy_models += 1 return { "overall_status": "healthy" if healthy_models == total_models else "degraded", "healthy_models": healthy_models, "total_models": total_models, "health_percentage": (healthy_models / total_models) * 100 if total_models > 0 else 0 } # Production monitoring setup monitor = FoundryMonitoringService() monitor.add_model("phi-4-mini") monitor.add_model("qwen2.5-0.5b") # Continuous monitoring async def monitoring_loop(): while True: metrics = await monitor.collect_metrics() health = monitor.get_health_status() if health["health_percentage"] < 100: logging.warning(f"System health degraded: {health}") await asyncio.sleep(30) # Collect metrics every 30 seconds ``` **Управление на ресурси и автоматично мащабиране**: ```python class FoundryResourceManager: def __init__(self): self.model_instances = {} self.resource_limits = { "max_memory_gb": 8, "max_concurrent_models": 3, "cpu_threshold": 80 } def auto_scale_models(self, demand_metrics: dict): """Automatically scale models based on demand.""" current_memory = self.get_total_memory_usage() # Scale down if memory usage is high if current_memory > self.resource_limits["max_memory_gb"] * 0.8: self.scale_down_idle_models() # Scale up if demand is high and resources allow for model_alias, demand in demand_metrics.items(): if demand > 0.8 and len(self.model_instances) < self.resource_limits["max_concurrent_models"]: self.load_model_instance(model_alias) def load_model_instance(self, alias: str) -> FoundryLocalManager: """Load a new model instance if resources allow.""" if alias not in self.model_instances: try: manager = FoundryLocalManager(alias) self.model_instances[alias] = manager logging.info(f"Loaded model instance: {alias}") return manager except Exception as e: logging.error(f"Failed to load model {alias}: {e}") return None return self.model_instances[alias] def scale_down_idle_models(self): """Remove idle model instances to free resources.""" idle_models = [] for alias, manager in self.model_instances.items(): if manager.get_idle_time() > 300: # 5 minutes idle idle_models.append(alias) for alias in idle_models: self.model_instances[alias].shutdown() del self.model_instances[alias] logging.info(f"Scaled down idle model: {alias}") ``` #### Усъвършенствана конфигурация и оптимизация **Персонализирана конфигурация на модели**: ```python # Advanced Foundry Local configuration for production from foundry_local import FoundryLocalManager, ModelConfig # Custom configuration for specific use cases config = ModelConfig( alias="phi-4-mini", quantization="Q5_K_M", # Specific quantization level context_length=4096, # Extended context for complex agents batch_size=1, # Optimized for single-user agents threads=4, # CPU thread optimization gpu_layers=32, # GPU acceleration layers memory_lock=True, # Lock model in memory for consistent performance numa=True # NUMA optimization for multi-socket systems ) manager = FoundryLocalManager(config=config) ``` **Контролен списък за производствено внедряване**: ✅ **Конфигурация на услуги**: - Конфигурирайте подходящи псевдоними на модели за случаи на употреба - Задайте ограничения на ресурсите и прагове за мониторинг - Активирайте проверки на здравето и събиране на метрики - Конфигурирайте автоматично рестартиране и резервиране ✅ **Настройка на сигурността**: - Активирайте локален достъп до API (без външно излагане) - Конфигурирайте подходящо управление на API ключове - Настройте регистриране на одити за взаимодействия на агенти - Внедрете ограничаване на скоростта за производствена употреба ✅ **Оптимизация на производителността**: - Тествайте производителността на модела при очаквано натоварване - Конфигурирайте подходящи нива на квантизация - Настройте стратегии за кеширане и предварително зареждане на модели - Наблюдавайте модели на използване на паметта и CPU ✅ **Тестване на интеграция**: - Тествайте интеграцията на агентната рамка - Проверете възможностите за офлайн работа - Т - Тествайте интеграцията на Microsoft Agent Framework - Проверете възможностите за работа офлайн - Тествайте сценарии за отказ и обработка на грешки - Валидирайте работните потоци на агентите от край до край **Сравнение с Foundry Local**: | Функция | Foundry Local | Ollama | |---------|---------------|--------| | **Целево приложение** | Производство в предприятия | Разработка и общност | | **Екосистема на модели** | Подбрана от Microsoft | Обширна общност | | **Оптимизация на хардуера** | Автоматична (CUDA/NPU/CPU) | Ръчна конфигурация | | **Функции за предприятия** | Вградени мониторинг и сигурност | Инструменти на общността | | **Сложност на внедряване** | Лесно (winget install) | Лесно (curl install) | | **Съвместимост на API** | OpenAI + разширения | OpenAI стандарт | | **Поддръжка** | Официална от Microsoft | Управлявана от общността | | **Най-добро за** | Производствени агенти | Прототипиране, изследвания | **Кога да изберете Ollama**: - **Разработка и прототипиране**: Бързи експерименти с различни модели - **Модели на общността**: Достъп до най-новите модели, създадени от общността - **Образователна употреба**: Обучение и преподаване на разработка на AI агенти - **Изследователски проекти**: Академични изследвания, изискващи разнообразен достъп до модели - **Персонализирани модели**: Създаване и тестване на персонализирани модели с фина настройка ### VLLM: Високопроизводителна инференция за SLM агенти VLLM (Very Large Language Model inference) предоставя високопроизводителен, ефективен по отношение на паметта инференционен двигател, специално оптимизиран за мащабни производствени внедрения на SLM. Докато Foundry Local се фокусира върху лекотата на използване, а Ollama акцентира върху моделите на общността, VLLM превъзхожда в сценарии с висока производителност, изискващи максимален капацитет и ефективно използване на ресурсите. **Основна архитектура и функции**: - **PagedAttention**: Революционно управление на паметта за ефективно изчисление на вниманието - **Динамично групиране**: Интелигентно групиране на заявки за оптимален капацитет - **Оптимизация за GPU**: Напреднали CUDA ядра и поддръжка на паралелизъм на тензори - **Съвместимост с OpenAI**: Пълна съвместимост на API за безпроблемна интеграция - **Спекулативно декодиране**: Напреднали техники за ускоряване на инференцията - **Поддръжка на квантизация**: INT4, INT8 и FP16 квантизация за ефективност на паметта #### Инсталация и настройка **Опции за инсталация**: ```bash # Standard installation pip install vllm # With additional dependencies for agent frameworks pip install vllm[agent] openai # Docker deployment for production docker pull vllm/vllm-openai:latest # From source for latest features git clone https://github.com/vllm-project/vllm.git cd vllm pip install -e . ``` **Бърз старт за разработка на агенти**: ```bash # Start VLLM server with SLM model python -m vllm.entrypoints.openai.api_server \ --model microsoft/Phi-3.5-mini-instruct \ --trust-remote-code \ --max-model-len 4096 \ --gpu-memory-utilization 0.8 # Alternative: Start with Qwen2.5 for lightweight agents python -m vllm.entrypoints.openai.api_server \ --model Qwen/Qwen2.5-0.5B-Instruct \ --trust-remote-code \ --max-model-len 2048 \ --tensor-parallel-size 1 # Test API endpoint curl http://localhost:8000/v1/models # Test chat completion curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "microsoft/Phi-3.5-mini-instruct", "messages": [{"role": "user", "content": "Hello!"}] }' ``` #### Интеграция на рамката за агенти **VLLM с Microsoft Agent Framework**: ```python from microsoft_agent_framework import Agent, Config import openai import subprocess import time import requests from typing import Optional, Dict, Any class VLLMManager: def __init__(self, model_name: str, host: str = "localhost", port: int = 8000, gpu_memory_utilization: float = 0.8, max_model_len: int = 4096): self.model_name = model_name self.host = host self.port = port self.base_url = f"http://{host}:{port}" self.gpu_memory_utilization = gpu_memory_utilization self.max_model_len = max_model_len self.process = None self.client = None def start_server(self) -> bool: """Start VLLM server with optimized settings for agents.""" try: cmd = [ "python", "-m", "vllm.entrypoints.openai.api_server", "--model", self.model_name, "--host", self.host, "--port", str(self.port), "--gpu-memory-utilization", str(self.gpu_memory_utilization), "--max-model-len", str(self.max_model_len), "--trust-remote-code", "--disable-log-requests", # Reduce logging for agents "--served-model-name", self.get_served_model_name() ] self.process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Wait for server to start max_retries = 30 for _ in range(max_retries): if self.health_check(): self.client = openai.OpenAI(base_url=f"{self.base_url}/v1") return True time.sleep(2) return False except Exception as e: print(f"Failed to start VLLM server: {e}") return False def get_served_model_name(self) -> str: """Get a clean model name for serving.""" return self.model_name.replace("/", "--") def health_check(self) -> bool: """Check if VLLM server is healthy.""" try: response = requests.get(f"{self.base_url}/health", timeout=5) return response.status_code == 200 except: return False def get_openai_client(self) -> openai.OpenAI: """Get OpenAI-compatible client for VLLM.""" if not self.client: self.client = openai.OpenAI(base_url=f"{self.base_url}/v1") return self.client def get_model_info(self) -> Dict[str, Any]: """Get model information and statistics.""" try: response = requests.get(f"{self.base_url}/v1/models") if response.status_code == 200: return response.json() except: pass return {} def shutdown(self): """Shutdown VLLM server.""" if self.process: self.process.terminate() self.process.wait() # Initialize VLLM for high-performance agents vllm_manager = VLLMManager("microsoft/Phi-3.5-mini-instruct") if vllm_manager.start_server(): print("VLLM server started successfully") # Configure agent with VLLM backend agent_config = Config( name="vllm-performance-agent", model_provider="vllm", model_id=vllm_manager.get_served_model_name(), endpoint=f"{vllm_manager.base_url}/v1", api_key="none" # VLLM doesn't require API key ) agent = Agent(config=agent_config) else: print("Failed to start VLLM server") ``` **Настройка за многопоточни агенти с висок капацитет**: ```python import asyncio from concurrent.futures import ThreadPoolExecutor from microsoft_agent_framework import Agent, Config import openai class VLLMHighThroughputManager: def __init__(self): self.model_configs = { "lightweight": { "model": "Qwen/Qwen2.5-0.5B-Instruct", "port": 8000, "max_model_len": 2048, "gpu_memory_utilization": 0.3 }, "balanced": { "model": "microsoft/Phi-3.5-mini-instruct", "port": 8001, "max_model_len": 4096, "gpu_memory_utilization": 0.5 }, "capable": { "model": "meta-llama/Llama-3.2-3B-Instruct", "port": 8002, "max_model_len": 8192, "gpu_memory_utilization": 0.7 } } self.managers = {} self.agents = {} self.client_pool = {} async def initialize_all_models(self): """Initialize all VLLM models in parallel.""" initialization_tasks = [] for category, config in self.model_configs.items(): task = self._initialize_model(category, config) initialization_tasks.append(task) results = await asyncio.gather(*initialization_tasks, return_exceptions=True) successful_inits = 0 for i, result in enumerate(results): category = list(self.model_configs.keys())[i] if isinstance(result, Exception): print(f"Failed to initialize {category}: {result}") else: successful_inits += 1 print(f"Successfully initialized {category} model") return successful_inits async def _initialize_model(self, category: str, config: Dict[str, Any]): """Initialize a single VLLM model instance.""" manager = VLLMManager( model_name=config["model"], port=config["port"], max_model_len=config["max_model_len"], gpu_memory_utilization=config["gpu_memory_utilization"] ) # Start server in thread to avoid blocking loop = asyncio.get_event_loop() with ThreadPoolExecutor() as executor: success = await loop.run_in_executor(executor, manager.start_server) if success: self.managers[category] = manager # Create agent agent_config = Config( name=f"vllm-{category}-agent", model_provider="vllm", model_id=manager.get_served_model_name(), endpoint=f"{manager.base_url}/v1", api_key="none" ) self.agents[category] = Agent(config=agent_config) # Create client pool for high throughput self.client_pool[category] = [ openai.OpenAI(base_url=f"{manager.base_url}/v1") for _ in range(5) # 5 clients per model for parallelism ] return True else: raise Exception(f"Failed to start VLLM server for {category}") def get_optimal_agent(self, request_complexity: str, current_load: Dict[str, int]) -> str: """Select optimal agent based on request complexity and current load.""" complexity_mapping = { "simple": "lightweight", "moderate": "balanced", "complex": "capable" } preferred_category = complexity_mapping.get(request_complexity, "balanced") # Check if preferred agent is available and not overloaded if (preferred_category in self.agents and current_load.get(preferred_category, 0) < 10): # Max 10 concurrent per agent return preferred_category # Fallback to least loaded available agent available_agents = [(cat, load) for cat, load in current_load.items() if cat in self.agents and load < 10] if available_agents: return min(available_agents, key=lambda x: x[1])[0] return "balanced" # Default fallback async def process_batch_requests(self, requests: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """Process multiple requests in parallel for maximum throughput.""" current_load = {cat: 0 for cat in self.agents.keys()} tasks = [] for request in requests: # Determine optimal agent complexity = request.get("complexity", "moderate") agent_category = self.get_optimal_agent(complexity, current_load) current_load[agent_category] += 1 # Create processing task task = self._process_single_request(request, agent_category) tasks.append(task) # Process all requests in parallel results = await asyncio.gather(*tasks, return_exceptions=True) # Format results formatted_results = [] for i, result in enumerate(results): if isinstance(result, Exception): formatted_results.append({ "request_id": requests[i].get("id", i), "status": "error", "error": str(result) }) else: formatted_results.append(result) return formatted_results async def _process_single_request(self, request: Dict[str, Any], agent_category: str) -> Dict[str, Any]: """Process a single request with the specified agent.""" start_time = time.time() try: agent = self.agents[agent_category] response = await agent.chat_async(request["message"]) processing_time = time.time() - start_time return { "request_id": request.get("id"), "status": "success", "response": response, "agent_used": agent_category, "processing_time": processing_time } except Exception as e: return { "request_id": request.get("id"), "status": "error", "error": str(e), "agent_used": agent_category, "processing_time": time.time() - start_time } # High-throughput usage example throughput_manager = VLLMHighThroughputManager() # Initialize all models initialized_count = await throughput_manager.initialize_all_models() print(f"Initialized {initialized_count} models") # Process batch requests batch_requests = [ {"id": 1, "message": "Simple question", "complexity": "simple"}, {"id": 2, "message": "Complex analysis needed", "complexity": "complex"}, {"id": 3, "message": "Moderate difficulty task", "complexity": "moderate"} ] results = await throughput_manager.process_batch_requests(batch_requests) for result in results: print(f"Request {result['request_id']}: {result['status']} in {result.get('processing_time', 0):.2f}s") ``` #### Модели за производствено внедряване **Производствена услуга VLLM за предприятия**: ```python import asyncio import logging import time from typing import Dict, List, Optional from dataclasses import dataclass from microsoft_agent_framework import Agent, Config import uvicorn from fastapi import FastAPI, HTTPException, BackgroundTasks from pydantic import BaseModel @dataclass class VLLMServerConfig: model_name: str port: int gpu_memory_utilization: float max_model_len: int tensor_parallel_size: int = 1 quantization: Optional[str] = None class AgentRequest(BaseModel): message: str agent_type: str = "general" priority: str = "normal" timeout: int = 30 class VLLMProductionService: def __init__(self, server_configs: Dict[str, VLLMServerConfig]): self.server_configs = server_configs self.managers = {} self.agents = {} self.metrics = { "requests_processed": 0, "requests_failed": 0, "total_processing_time": 0, "agent_usage": {name: 0 for name in server_configs.keys()}, "throughput_per_minute": 0 } self.request_queue = asyncio.Queue(maxsize=1000) self.processing_workers = [] self.app = FastAPI(title="VLLM Agent Service") self._setup_routes() async def initialize_production_environment(self): """Initialize all VLLM servers for production.""" logging.info("Initializing VLLM production environment...") initialization_tasks = [] for name, config in self.server_configs.items(): task = self._initialize_server(name, config) initialization_tasks.append(task) results = await asyncio.gather(*initialization_tasks, return_exceptions=True) successful_servers = 0 for i, result in enumerate(results): server_name = list(self.server_configs.keys())[i] if isinstance(result, Exception): logging.error(f"Failed to initialize {server_name}: {result}") else: successful_servers += 1 logging.info(f"Successfully initialized {server_name}") if successful_servers == 0: raise Exception("No VLLM servers could be initialized") # Start processing workers self.processing_workers = [ asyncio.create_task(self._processing_worker(i)) for i in range(min(4, successful_servers)) # 4 workers max ] logging.info(f"Production environment ready with {successful_servers} servers") return successful_servers async def _initialize_server(self, name: str, config: VLLMServerConfig): """Initialize a single VLLM server.""" manager = VLLMManager( model_name=config.model_name, port=config.port, gpu_memory_utilization=config.gpu_memory_utilization, max_model_len=config.max_model_len ) # Add quantization if specified if config.quantization: # This would be added to the manager's start command pass success = manager.start_server() if success: self.managers[name] = manager # Create production agent agent_config = Config( name=f"vllm-production-{name}", model_provider="vllm", model_id=manager.get_served_model_name(), endpoint=f"{manager.base_url}/v1", api_key="none", timeout=30.0 ) agent = Agent(config=agent_config) # Add production tools self._add_production_tools(agent, name) self.agents[name] = agent return True else: raise Exception(f"Failed to start VLLM server for {name}") def _add_production_tools(self, agent: Agent, server_type: str): """Add production tools based on server type.""" if server_type == "customer_service": @agent.tool def escalate_to_human(issue: str, customer_id: str) -> str: """Escalate complex issues to human agents.""" return f"Escalated issue for customer {customer_id}: {issue}" @agent.tool def lookup_order_status(order_id: str) -> dict: """Look up order status from production database.""" # Production database lookup return {"order_id": order_id, "status": "shipped", "eta": "2 days"} elif server_type == "technical_support": @agent.tool def run_system_diagnostics(system_id: str) -> dict: """Run comprehensive system diagnostics.""" return {"system_id": system_id, "status": "healthy", "issues": []} @agent.tool def create_incident_report(description: str, severity: str) -> str: """Create incident report in production system.""" incident_id = f"INC-{hash(description) % 100000:05d}" return f"Created incident {incident_id} with severity {severity}" def _setup_routes(self): """Set up FastAPI routes for production service.""" @self.app.post("/chat") async def chat_endpoint(request: AgentRequest, background_tasks: BackgroundTasks): try: # Add request to queue await self.request_queue.put({ "request": request, "timestamp": time.time(), "future": asyncio.Future() }) # Wait for processing (with timeout) result = await asyncio.wait_for( self._wait_for_result(request), timeout=request.timeout ) return result except asyncio.TimeoutError: raise HTTPException(status_code=408, detail="Request timeout") except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @self.app.get("/health") async def health_endpoint(): return await self.get_health_status() @self.app.get("/metrics") async def metrics_endpoint(): return self.get_production_metrics() async def _processing_worker(self, worker_id: int): """Background worker for processing agent requests.""" logging.info(f"Starting processing worker {worker_id}") while True: try: # Get request from queue queue_item = await self.request_queue.get() request_data = queue_item["request"] request_future = queue_item["future"] # Select appropriate agent agent_name = self._select_agent(request_data.agent_type) if agent_name not in self.agents: request_future.set_exception(Exception(f"Agent {agent_name} not available")) continue # Process request start_time = time.time() try: agent = self.agents[agent_name] response = await agent.chat_async(request_data.message) processing_time = time.time() - start_time # Update metrics self.metrics["requests_processed"] += 1 self.metrics["total_processing_time"] += processing_time self.metrics["agent_usage"][agent_name] += 1 result = { "response": response, "agent_used": agent_name, "processing_time": processing_time, "worker_id": worker_id } request_future.set_result(result) except Exception as e: self.metrics["requests_failed"] += 1 request_future.set_exception(e) finally: self.request_queue.task_done() except Exception as e: logging.error(f"Worker {worker_id} error: {e}") await asyncio.sleep(1) def _select_agent(self, agent_type: str) -> str: """Select appropriate agent based on request type.""" agent_mapping = { "customer_service": "customer_service", "technical": "technical_support", "general": "general_purpose" } return agent_mapping.get(agent_type, "general_purpose") async def _wait_for_result(self, request: AgentRequest): """Wait for request processing to complete.""" # This is simplified - in production you'd track futures properly await asyncio.sleep(0.1) # Placeholder return {"response": "Processed", "status": "success"} async def get_health_status(self) -> dict: """Get comprehensive health status of all services.""" health_status = { "overall_status": "healthy", "servers": {}, "queue_size": self.request_queue.qsize(), "active_workers": len([w for w in self.processing_workers if not w.done()]), "timestamp": time.time() } unhealthy_servers = 0 for name, manager in self.managers.items(): try: is_healthy = manager.health_check() health_status["servers"][name] = { "status": "healthy" if is_healthy else "unhealthy", "endpoint": manager.base_url, "model": manager.model_name } if not is_healthy: unhealthy_servers += 1 except Exception as e: health_status["servers"][name] = { "status": "error", "error": str(e) } unhealthy_servers += 1 if unhealthy_servers > 0: health_status["overall_status"] = "degraded" if unhealthy_servers < len(self.managers) else "unhealthy" return health_status def get_production_metrics(self) -> dict: """Get production performance metrics.""" total_requests = self.metrics["requests_processed"] + self.metrics["requests_failed"] avg_processing_time = ( self.metrics["total_processing_time"] / self.metrics["requests_processed"] if self.metrics["requests_processed"] > 0 else 0 ) success_rate = ( self.metrics["requests_processed"] / total_requests * 100 if total_requests > 0 else 0 ) return { "total_requests": total_requests, "successful_requests": self.metrics["requests_processed"], "failed_requests": self.metrics["requests_failed"], "success_rate_percent": success_rate, "average_processing_time_seconds": avg_processing_time, "agent_usage_distribution": self.metrics["agent_usage"], "queue_size": self.request_queue.qsize() } async def start_production_server(self, host: str = "0.0.0.0", port: int = 8080): """Start the production FastAPI server.""" config = uvicorn.Config( self.app, host=host, port=port, log_level="info", workers=1 # Single worker for simplicity ) server = uvicorn.Server(config) await server.serve() # Production deployment example production_configs = { "customer_service": VLLMServerConfig( model_name="microsoft/Phi-3.5-mini-instruct", port=8000, gpu_memory_utilization=0.4, max_model_len=4096 ), "technical_support": VLLMServerConfig( model_name="meta-llama/Llama-3.2-3B-Instruct", port=8001, gpu_memory_utilization=0.6, max_model_len=8192 ), "general_purpose": VLLMServerConfig( model_name="Qwen/Qwen2.5-1.5B-Instruct", port=8002, gpu_memory_utilization=0.3, max_model_len=2048 ) } production_service = VLLMProductionService(production_configs) # Initialize and start production service # await production_service.initialize_production_environment() # await production_service.start_production_server() ``` #### Функции за предприятия и мониторинг **Напреднал мониторинг на производителността на VLLM**: ```python import psutil import nvidia_ml_py3 as nvml from dataclasses import dataclass from typing import List, Dict, Optional import json import asyncio @dataclass class PerformanceMetrics: timestamp: float requests_per_second: float average_latency_ms: float gpu_utilization_percent: float gpu_memory_used_gb: float cpu_utilization_percent: float memory_used_gb: float queue_length: int active_requests: int class VLLMAdvancedMonitoring: def __init__(self, vllm_managers: Dict[str, VLLMManager]): self.managers = vllm_managers self.metrics_history = [] self.alert_thresholds = { "gpu_utilization_max": 95, "gpu_memory_max_gb": 10, "latency_max_ms": 3000, "queue_length_max": 50, "error_rate_max_percent": 10 } # Initialize NVIDIA ML for GPU monitoring try: nvml.nvmlInit() self.gpu_monitoring_available = True self.gpu_count = nvml.nvmlDeviceGetCount() except: self.gpu_monitoring_available = False self.gpu_count = 0 async def collect_comprehensive_metrics(self) -> Dict[str, PerformanceMetrics]: """Collect detailed performance metrics for all VLLM instances.""" all_metrics = {} for name, manager in self.managers.items(): try: metrics = await self._collect_single_instance_metrics(name, manager) all_metrics[name] = metrics except Exception as e: logging.error(f"Failed to collect metrics for {name}: {e}") # Create error metrics all_metrics[name] = PerformanceMetrics( timestamp=time.time(), requests_per_second=0, average_latency_ms=0, gpu_utilization_percent=0, gpu_memory_used_gb=0, cpu_utilization_percent=0, memory_used_gb=0, queue_length=0, active_requests=0 ) return all_metrics async def _collect_single_instance_metrics(self, name: str, manager: VLLMManager) -> PerformanceMetrics: """Collect metrics for a single VLLM instance.""" timestamp = time.time() # Get VLLM-specific metrics via API vllm_stats = await self._get_vllm_stats(manager) # Get system metrics cpu_percent = psutil.cpu_percent(interval=0.1) memory_info = psutil.virtual_memory() memory_used_gb = memory_info.used / (1024**3) # Get GPU metrics if available gpu_utilization = 0 gpu_memory_used = 0 if self.gpu_monitoring_available and self.gpu_count > 0: try: # Assuming first GPU for simplicity handle = nvml.nvmlDeviceGetHandleByIndex(0) gpu_util = nvml.nvmlDeviceGetUtilizationRates(handle) gpu_utilization = gpu_util.gpu gpu_mem = nvml.nvmlDeviceGetMemoryInfo(handle) gpu_memory_used = gpu_mem.used / (1024**3) except Exception as e: logging.warning(f"GPU monitoring failed: {e}") return PerformanceMetrics( timestamp=timestamp, requests_per_second=vllm_stats.get("requests_per_second", 0), average_latency_ms=vllm_stats.get("average_latency_ms", 0), gpu_utilization_percent=gpu_utilization, gpu_memory_used_gb=gpu_memory_used, cpu_utilization_percent=cpu_percent, memory_used_gb=memory_used_gb, queue_length=vllm_stats.get("queue_length", 0), active_requests=vllm_stats.get("active_requests", 0) ) async def _get_vllm_stats(self, manager: VLLMManager) -> dict: """Get VLLM-specific statistics via API calls.""" try: # Test inference to measure latency start_time = time.time() client = manager.get_openai_client() response = await asyncio.wait_for( asyncio.to_thread( client.chat.completions.create, model=manager.get_served_model_name(), messages=[{"role": "user", "content": "ping"}], max_tokens=1 ), timeout=5.0 ) latency_ms = (time.time() - start_time) * 1000 return { "average_latency_ms": latency_ms, "requests_per_second": 1000 / latency_ms if latency_ms > 0 else 0, "queue_length": 0, # Would need to be exposed by VLLM "active_requests": 1 # Approximation } except Exception as e: logging.warning(f"Failed to get VLLM stats: {e}") return { "average_latency_ms": 0, "requests_per_second": 0, "queue_length": 0, "active_requests": 0 } def generate_performance_report(self, time_window_minutes: int = 60) -> dict: """Generate comprehensive performance report.""" cutoff_time = time.time() - (time_window_minutes * 60) recent_metrics = [ metrics for metrics in self.metrics_history if any(m.timestamp > cutoff_time for m in metrics.values()) ] if not recent_metrics: return {"error": "No recent metrics available"} report = { "time_window_minutes": time_window_minutes, "total_samples": len(recent_metrics), "instances": {} } # Analyze each instance for instance_name in self.managers.keys(): instance_metrics = [ metrics[instance_name] for metrics in recent_metrics if instance_name in metrics ] if instance_metrics: report["instances"][instance_name] = { "avg_latency_ms": sum(m.average_latency_ms for m in instance_metrics) / len(instance_metrics), "max_latency_ms": max(m.average_latency_ms for m in instance_metrics), "avg_gpu_utilization": sum(m.gpu_utilization_percent for m in instance_metrics) / len(instance_metrics), "avg_requests_per_second": sum(m.requests_per_second for m in instance_metrics) / len(instance_metrics), "max_queue_length": max(m.queue_length for m in instance_metrics), "availability_percent": (len(instance_metrics) / len(recent_metrics)) * 100 } return report async def auto_scaling_recommendations(self) -> List[dict]: """Generate auto-scaling recommendations based on performance metrics.""" recommendations = [] if not self.metrics_history: return recommendations latest_metrics = self.metrics_history[-1] for instance_name, metrics in latest_metrics.items(): # High latency recommendation if metrics.average_latency_ms > self.alert_thresholds["latency_max_ms"]: recommendations.append({ "instance": instance_name, "type": "scale_up", "reason": f"High latency: {metrics.average_latency_ms:.0f}ms", "suggestion": "Consider adding tensor parallelism or increasing GPU memory" }) # High GPU utilization recommendation if metrics.gpu_utilization_percent > self.alert_thresholds["gpu_utilization_max"]: recommendations.append({ "instance": instance_name, "type": "scale_out", "reason": f"High GPU utilization: {metrics.gpu_utilization_percent:.1f}%", "suggestion": "Consider adding additional GPU instances" }) # Low utilization recommendation if (metrics.gpu_utilization_percent < 20 and metrics.requests_per_second < 1): recommendations.append({ "instance": instance_name, "type": "scale_down", "reason": f"Low utilization: {metrics.gpu_utilization_percent:.1f}% GPU, {metrics.requests_per_second:.1f} RPS", "suggestion": "Consider consolidating workloads or reducing resources" }) return recommendations # Advanced monitoring setup monitoring = VLLMAdvancedMonitoring({ "customer_service": vllm_manager, # Add other managers as needed }) async def advanced_monitoring_loop(): """Advanced monitoring with auto-scaling recommendations.""" while True: try: # Collect metrics metrics = await monitoring.collect_comprehensive_metrics() monitoring.metrics_history.append(metrics) # Keep only last 1000 entries if len(monitoring.metrics_history) > 1000: monitoring.metrics_history = monitoring.metrics_history[-1000:] # Generate recommendations every 5 minutes if len(monitoring.metrics_history) % 10 == 0: # Every 10th collection (5 minutes if collecting every 30s) recommendations = await monitoring.auto_scaling_recommendations() if recommendations: logging.info(f"Auto-scaling recommendations: {recommendations}") # Generate performance report every hour if len(monitoring.metrics_history) % 120 == 0: # Every 120th collection (1 hour) report = monitoring.generate_performance_report(60) logging.info(f"Performance report: {json.dumps(report, indent=2)}") except Exception as e: logging.error(f"Advanced monitoring error: {e}") await asyncio.sleep(30) # Collect metrics every 30 seconds # Start advanced monitoring # asyncio.create_task(advanced_monitoring_loop()) ``` #### Напреднала конфигурация и оптимизация **Шаблони за конфигурация на VLLM за производство**: ```python from enum import Enum from typing import Dict, Any class DeploymentScenario(Enum): DEVELOPMENT = "development" STAGING = "staging" PRODUCTION_LOW = "production_low" PRODUCTION_HIGH = "production_high" ENTERPRISE = "enterprise" class VLLMConfigTemplates: """Production-ready VLLM configuration templates.""" @staticmethod def get_config_template(scenario: DeploymentScenario) -> Dict[str, Any]: """Get optimized configuration for deployment scenario.""" templates = { DeploymentScenario.DEVELOPMENT: { "gpu_memory_utilization": 0.6, "max_model_len": 2048, "tensor_parallel_size": 1, "pipeline_parallel_size": 1, "quantization": None, "enable_prefix_caching": False, "max_num_seqs": 32, "max_num_batched_tokens": 2048 }, DeploymentScenario.STAGING: { "gpu_memory_utilization": 0.8, "max_model_len": 4096, "tensor_parallel_size": 1, "pipeline_parallel_size": 1, "quantization": "awq", "enable_prefix_caching": True, "max_num_seqs": 64, "max_num_batched_tokens": 4096 }, DeploymentScenario.PRODUCTION_LOW: { "gpu_memory_utilization": 0.85, "max_model_len": 4096, "tensor_parallel_size": 1, "pipeline_parallel_size": 1, "quantization": "awq", "enable_prefix_caching": True, "max_num_seqs": 128, "max_num_batched_tokens": 8192, "enable_chunked_prefill": True }, DeploymentScenario.PRODUCTION_HIGH: { "gpu_memory_utilization": 0.9, "max_model_len": 8192, "tensor_parallel_size": 2, "pipeline_parallel_size": 1, "quantization": "awq", "enable_prefix_caching": True, "max_num_seqs": 256, "max_num_batched_tokens": 16384, "enable_chunked_prefill": True, "speculative_model": "small_draft_model" }, DeploymentScenario.ENTERPRISE: { "gpu_memory_utilization": 0.95, "max_model_len": 16384, "tensor_parallel_size": 4, "pipeline_parallel_size": 2, "quantization": "awq", "enable_prefix_caching": True, "max_num_seqs": 512, "max_num_batched_tokens": 32768, "enable_chunked_prefill": True, "speculative_model": "optimized_draft_model", "guided_decoding_backend": "outlines" } } return templates[scenario] @staticmethod def generate_vllm_command(model_name: str, scenario: DeploymentScenario, port: int = 8000, host: str = "0.0.0.0") -> List[str]: """Generate optimized VLLM command for deployment scenario.""" config = VLLMConfigTemplates.get_config_template(scenario) cmd = [ "python", "-m", "vllm.entrypoints.openai.api_server", "--model", model_name, "--host", host, "--port", str(port), "--gpu-memory-utilization", str(config["gpu_memory_utilization"]), "--max-model-len", str(config["max_model_len"]), "--tensor-parallel-size", str(config["tensor_parallel_size"]), "--max-num-seqs", str(config["max_num_seqs"]), "--max-num-batched-tokens", str(config["max_num_batched_tokens"]), "--trust-remote-code", "--disable-log-requests" ] # Add optional parameters if config.get("quantization"): cmd.extend(["--quantization", config["quantization"]]) if config.get("enable_prefix_caching"): cmd.append("--enable-prefix-caching") if config.get("enable_chunked_prefill"): cmd.append("--enable-chunked-prefill") if config.get("pipeline_parallel_size", 1) > 1: cmd.extend(["--pipeline-parallel-size", str(config["pipeline_parallel_size"])]) if config.get("speculative_model"): cmd.extend(["--speculative-model", config["speculative_model"]]) return cmd # Usage examples dev_cmd = VLLMConfigTemplates.generate_vllm_command( "microsoft/Phi-3.5-mini-instruct", DeploymentScenario.DEVELOPMENT, port=8000 ) prod_cmd = VLLMConfigTemplates.generate_vllm_command( "microsoft/Phi-3.5-mini-instruct", DeploymentScenario.PRODUCTION_HIGH, port=8001 ) print(f"Development command: {' '.join(dev_cmd)}") print(f"Production command: {' '.join(prod_cmd)}") ``` **Контролен списък за производствено внедряване на VLLM**: ✅ **Оптимизация на хардуера**: - Конфигурирайте паралелизъм на тензори за многопроцесорни настройки - Активирайте квантизация (AWQ/GPTQ) за ефективност на паметта - Настройте оптимално използване на паметта на GPU (85-95%) - Конфигурирайте подходящи размери на групите за капацитет ✅ **Настройка на производителността**: - Активирайте кеширане на префикси за повтарящи се заявки - Конфигурирайте предварително запълване на части за дълги последователности - Настройте спекулативно декодиране за по-бърза инференция - Оптимизирайте max_num_seqs според хардуера ✅ **Функции за производство**: - Настройте мониторинг на здравето и събиране на метрики - Конфигурирайте автоматично рестартиране и резервиране - Имплементирайте опашки за заявки и балансиране на натоварването - Настройте цялостно логване и известия ✅ **Сигурност и надеждност**: - Конфигурирайте правила за защитна стена и контроли за достъп - Настройте ограничаване на API и автентикация - Имплементирайте плавно изключване и почистване - Конфигурирайте резервни копия и възстановяване при бедствия ✅ **Тестване на интеграция**: - Тествайте интеграцията на Microsoft Agent Framework - Валидирайте сценарии с висок капацитет - Тествайте процедури за отказ и възстановяване - Измерете производителността при натоварване **Сравнение с други решения**: | Функция | VLLM | Foundry Local | Ollama | |---------|------|---------------|--------| | **Целево приложение** | Производство с висок капацитет | Лесно използване в предприятия | Разработка и общност | | **Производителност** | Максимален капацитет | Балансирана | Добра | | **Ефективност на паметта** | Оптимизация с PagedAttention | Автоматична оптимизация | Стандартна | | **Сложност на настройката** | Висока (много параметри) | Ниска (автоматична) | Ниска (лесна) | | **Мащабируемост** | Отлична (паралелизъм на тензори/потоци) | Добра | Ограничена | | **Квантизация** | Напреднала (AWQ, GPTQ, FP8) | Автоматична | Стандартна GGUF | | **Функции за предприятия** | Нужна персонализирана имплементация | Вградени | Инструменти на общността | | **Най-добро за** | Агенти за производство с голям мащаб | Производство в предприятия | Разработка | **Кога да изберете VLLM**: - **Изисквания за висок капацитет**: Обработка на стотици заявки в секунда - **Големи внедрения**: Многопроцесорни, многовъзлови внедрения - **Критична производителност**: Време за отговор под секунда при мащаб - **Напреднала оптимизация**: Нужда от персонализирана квантизация и групиране - **Ефективност на ресурсите**: Максимално използване на скъп хардуер GPU ## Реални приложения на SLM агенти ### SLM агенти за обслужване на клиенти - **Възможности на SLM**: Проверка на акаунти, нулиране на пароли, проверка на статус на поръчки - **Ползи за разходите**: 10-кратно намаление на разходите за инференция в сравнение с LLM агенти - **Производителност**: По-бързо време за отговор с постоянна качество за рутинни заявки ### SLM агенти за бизнес процеси - **Агенти за обработка на фактури**: Извличане на данни, валидиране на информация, маршрутизиране за одобрение - **Агенти за управление на имейли**: Категоризиране, приоритизиране, автоматично съставяне на отговори - **Агенти за планиране**: Координиране на срещи, управление на календари, изпращане на напомняния ### Лични SLM дигитални асистенти - **Агенти за управление на задачи**: Създаване, актуализиране, организиране на списъци със задачи ефективно - **Агенти за събиране на информация**: Изследване на теми, обобщаване на открития локално - **Агенти за комуникация**: Съставяне на имейли, съобщения, публикации в социални медии частно ### SLM агенти за търговия и финанси - **Агенти за мониторинг на пазара**: Проследяване на цени, идентифициране на тенденции в реално време - **Агенти за генериране на отчети**: Автоматично създаване на дневни/седмични обобщения - **Агенти за оценка на риска**: Оценка на позиции в портфейла с използване на локални данни ### SLM агенти за здравеопазване - **Агенти за планиране на пациенти**: Координиране на срещи, изпращане на автоматизирани напомняния - **Агенти за документация**: Генериране на медицински обобщения, отчети локално - **Агенти за управление на рецепти**: Проследяване на презареждания, проверка на взаимодействия частно ## Microsoft Agent Framework: Разработка на агенти, готови за производство ### Преглед и архитектура Microsoft Agent Framework предоставя цялостна, корпоративна платформа за изграждане, внедряване и управление на AI агенти, които могат да работят както в облака, така и в офлайн среди на ръба. Рамката е специално проектирана да работи безпроблемно с малки езикови модели и сценарии за изчисления на ръба, което я прави идеална за внедрения, чувствителни към поверителност и ограничени ресурси. **Основни компоненти на рамката**: - **Среда за изпълнение на агенти**: Лека среда за изпълнение, оптимизирана за устройства на ръба - **Система за интеграция на инструменти**: Разширяема архитектура на плъгини за свързване на външни услуги и API - **Управление на състоянието**: Постоянна памет на агента и обработка на контекста между сесиите - **Слой за сигурност**: Вградени контроли за сигурност за корпоративно внедрение - **Двигател за оркестрация**: Координация на множество агенти и управление на работни потоци ### Основни функции за внедрение на ръба **Архитектура с приоритет на офлайн работа**: Microsoft Agent Framework е проектирана с принципи за приоритет на офлайн работа, позволявайки на агентите да работят ефективно без постоянна интернет връзка. Това включва локална инференция на модели, кеширани бази знания, офлайн изпълнение на инструменти и плавно намаляване на функционалността, когато облачните услуги не са налични. **Оптимизация на ресурсите**: Рамката предоставя интелигентно управление на ресурсите с автоматична оптимизация на паметта за SLM, балансиране на натоварването на CPU/GPU за устройства на ръба, адаптивен избор на модели според наличните ресурси и енергийно ефективни модели на инференция за мобилно внедрение. **Сигурност и поверителност**: Функциите за сигурност от корпоративен клас включват локална обработка на данни за запазване на поверителността, криптирани комуникационни канали на агента, контроли за достъп на базата на роли за възможностите на агента и регистриране на действия за изисквания за съответствие. ### Интеграция с Foundry Local Microsoft Agent Framework се интегрира безпроблемно с Foundry Local, за да предостави цялостно AI решение за ръба: **Автоматично откриване на модели**: Рамката автоматично открива и се свързва с инстанции на Foundry Local, открива наличните SLM модели и избира оптимални модели според изискванията на агента и възможностите на хардуера. **Динамично зареждане на модели**: Агенти могат динамично да зареждат различни SLM за специфични задачи, позволявайки системи с множество модели, където различни модели обработват различни типове заявки, и автоматично резервиране между модели според наличността и производителността. **Оптимизация на производителността**: Интегрирани механизми за кеширане намаляват времето за зареждане на модели, пулове за връзки оптимизират API обажданията към Foundry Local, а интелигентното групиране подобрява капацитета за множество заявки на агенти. ### Създаване на агенти с Microsoft Agent Framework #### Дефиниция и конфигурация на агенти ```python from microsoft_agent_framework import Agent, Tool, Config from foundry_local import FoundryLocalManager # Configure agent with Foundry Local integration config = Config( name="customer-service-agent", model_provider="foundry-local", model_alias="phi-4-mini", max_tokens=512, temperature=0.1, offline_mode=True ) # Initialize Foundry Local connection foundry = FoundryLocalManager("phi-4-mini") # Create agent instance agent = Agent( config=config, model_endpoint=foundry.endpoint, api_key=foundry.api_key ) ``` #### Интеграция на инструменти за сценарии на ръба ```python # Define tools for offline operation @agent.tool def lookup_customer_info(customer_id: str) -> dict: """Look up customer information from local database.""" # Local database query - works offline return local_db.get_customer(customer_id) @agent.tool def create_support_ticket(issue: str, priority: str) -> str: """Create a support ticket in local system.""" # Local ticket creation with sync when online ticket_id = local_system.create_ticket(issue, priority) return f"Ticket {ticket_id} created successfully" @agent.tool def schedule_callback(customer_id: str, preferred_time: str) -> str: """Schedule a callback for the customer.""" # Local scheduling with calendar integration return local_calendar.schedule(customer_id, preferred_time) ``` #### Оркестрация на множество агенти ```python from microsoft_agent_framework import AgentOrchestrator # Create specialized agents for different domains scheduling_agent = Agent( config=Config( name="scheduling-agent", model_alias="qwen2.5-0.5b", # Lightweight for simple tasks specialized_for="scheduling" ) ) technical_support_agent = Agent( config=Config( name="technical-agent", model_alias="phi-4-mini", # More capable for complex issues specialized_for="technical_support" ) ) # Orchestrate multiple agents orchestrator = AgentOrchestrator([ scheduling_agent, technical_support_agent ]) # Route requests based on intent result = orchestrator.process_request( "I need to schedule a callback for a technical issue", routing_strategy="intent-based" ) ``` ### Напреднали модели за внедрение на ръба #### Йерархична архитектура на агенти **Клъстери от локални агенти**: Внедрете множество специализирани SLM агенти на устройства на ръба, всеки оптимизиран за специфични задачи. Използвайте леки модели като Qwen2.5-0.5B за просто маршрутизиране и планиране, средни модели като Phi-4-Mini за обслужване на клиенти и документация, и по-големи модели за сложни разсъждения, когато ресурсите позволяват. **Координация между ръба и облака**: Имплементирайте интелигентни модели за ескалация, където локалните агенти обработват рутинни задачи, облачните агенти предоставят сложни разсъждения, когато има връзка, и плавно предаване между обработката на ръба и облака запазва непрекъснатостта. #### Конфигурации за внедрение **Внедрение на едно устройство**: ```yaml deployment: type: single-device hardware: edge-device models: - alias: "phi-4-mini" primary: true tasks: ["conversation", "reasoning"] - alias: "qwen2.5-0.5b" secondary: true tasks: ["routing", "classification"] agents: - name: "primary-agent" model: "phi-4-mini" tools: ["database", "calendar", "email"] ``` **Разпределено внедрение на ръба**: ```yaml deployment: type: distributed-edge nodes: - id: "edge-1" agents: ["customer-service", "scheduling"] models: ["phi-4-mini"] - id: "edge-2" agents: ["technical-support", "documentation"] models: ["qwen2.5-coder-0.5b"] coordination: load_balancing: true failover: automatic ``` ### Оптимизация на производителността за агенти на ръба #### Стратегии за избор на модели **Задачо-базирано разпределение на модели**: Microsoft Agent Framework позволява интелигентен избор на модели според сложността на задачата и изискванията: - **Прости задачи** (Q&A, маршрутизиране): Qwen2.5-0.5B (500MB, <100ms отговор) - **Умерени задачи** (обслужване на клиенти, планиране): Phi-4-Mini (2.4GB, 200-500ms отговор) - **Сложни задачи** (технически анализ, планиране): Phi-4 (7GB, 1-3s отговор, когато ресурсите позволяват) **Динамично превключване на модели**: Агенти могат да превключват между модели според текущото натоварване на системата, оценка на сложността на задачата, приоритетни нива на потребителя и наличните хардуерни ресурси. #### Управление на паметта и ресурсите ```python # Configure resource constraints for edge deployment resource_config = ResourceConfig( max_memory_usage="4GB", max_concurrent_agents=3, model_cache_size="2GB", auto_unload_idle_models=True, power_management=True ) agent = Agent( config=config, resource_limits=resource_config ) ``` ### Модели за интеграция в предприятия #### Сигурност и съответствие **Локална обработка на данни**: Всички действия на агента се извършват локално, гарантирайки, че чувствителните данни никога не напускат устройството на ръба. Това включва защита на информацията за клиенти, съответствие с HIPAA за агенти в здравеопазването, сигурност на финансови данни за банкови агенти и съответствие с GDPR за внедрения в Европа. **Контрол на достъпа**: Разрешения на базата на роли контролират кои инструменти могат да бъдат достъпни от агенти, автентикация на потребителите за взаимодействия с агенти и регистриране на всички действия и решения на агента. #### Мониторинг и наблюдаемост ```python from microsoft_agent_framework import AgentMonitor # Set up monitoring for edge agents monitor = AgentMonitor( metrics=["response_time", "success_rate", "resource_usage"], alerts=[ {"metric": "response_time", "threshold": "2s", "action": "scale_down_model"}, {"metric": "memory_usage", "threshold": "80%", "action": "unload_idle_agents"} ], local_storage=True # Store metrics locally for offline operation ) agent.add_monitor(monitor) ``` ### Реални примери за имплементация #### Система за агенти на ръба в търговията на дребно ```python # Retail kiosk agent for in-store customer assistance retail_agent = Agent( config=Config( name="retail-assistant", model_alias="phi-4-mini", context="You are a helpful retail assistant in an electronics store." ) ) @retail_agent.tool def check_inventory(product_sku: str) -> dict: """Check local inventory for a product.""" return local_inventory.lookup(product_sku) @retail_agent.tool def find_alternatives(product_category: str) -> list: """Find alternative products in the same category.""" return local_catalog.find_similar(product_category) @retail_agent.tool def create_price_quote(items: list) -> dict: """Generate a price quote for multiple items.""" return pricing_engine.calculate_quote(items) ``` #### Агенти за подкрепа в здравеопазването @@CODE **Избор на рамка за разгръщане на агенти**: Изберете оптимизационни рамки според целевия хардуер и изискванията на агента. Използвайте Llama.cpp за разгръщане на агенти, оптимизирани за CPU, Apple MLX за приложения на агенти за Apple Silicon и ONNX за съвместимост на агенти на различни платформи. ## Практическо преобразуване и приложения на SLM агенти ### Реални сценарии за разгръщане на агенти **Мобилни приложения за агенти**: Форматите Q4_K са отлични за приложения на агенти за смартфони с минимално използване на памет, докато Q8_0 предлага балансирана производителност за системи на агенти за таблети. Форматите Q5_K осигуряват високо качество за мобилни агенти за продуктивност. **Компютърни и Edge приложения за агенти**: Q5_K предоставя оптимална производителност за приложения на агенти за настолни компютри, Q8_0 осигурява високо качество на изводите за работни станции, а Q4_K позволява ефективна обработка на Edge устройства. **Изследователски и експериментални агенти**: Напредналите формати за квантизация позволяват изследване на ултра-ниска прецизност на изводите на агенти за академични изследвания и доказателства за концепции, изискващи екстремни ограничения на ресурсите. ### Бенчмаркове за производителност на SLM агенти **Скорост на изводите на агенти**: Q4_K постига най-бързи времена за отговор на агенти на мобилни CPU, Q5_K осигурява балансирано съотношение между скорост и качество за общи приложения на агенти, Q8_0 предлага високо качество за сложни задачи на агенти, а експерименталните формати осигуряват максимален капацитет за специализиран хардуер за агенти. **Изисквания за памет на агенти**: Нивата на квантизация за агенти варират от Q2_K (под 500MB за малки модели на агенти) до Q8_0 (приблизително 50% от оригиналния размер), като експерименталните конфигурации постигат максимална компресия за среди с ограничени ресурси. ## Предизвикателства и съображения за SLM агенти ### Компромиси в производителността на системите за агенти Разгръщането на SLM агенти изисква внимателно обмисляне на компромисите между размера на модела, скоростта на отговор на агента и качеството на изхода. Докато Q4_K предлага изключителна скорост и ефективност за мобилни агенти, Q8_0 осигурява високо качество за сложни задачи на агенти. Q5_K намира среден път, подходящ за повечето общи приложения на агенти. ### Съвместимост на хардуера за SLM агенти Различните Edge устройства имат различни възможности за разгръщане на SLM агенти. Q4_K работи ефективно на основни процесори за прости агенти, Q5_K изисква умерени изчислителни ресурси за балансирана производителност на агенти, а Q8_0 се възползва от висококачествен хардуер за напреднали възможности на агенти. ### Сигурност и поверителност в системите за SLM агенти Докато SLM агентите позволяват локална обработка за подобрена поверителност, трябва да се внедрят подходящи мерки за сигурност за защита на моделите на агенти и данните в Edge среди. Това е особено важно при разгръщане на формати на агенти с висока прецизност в корпоративни среди или компресирани формати на агенти в приложения, обработващи чувствителни данни. ## Бъдещи тенденции в разработката на SLM агенти Пейзажът на SLM агентите продължава да се развива с напредъка в техниките за компресия, методите за оптимизация и стратегиите за разгръщане на Edge. Бъдещите разработки включват по-ефективни алгоритми за квантизация на модели на агенти, подобрени методи за компресия на работните потоци на агенти и по-добра интеграция с хардуерни ускорители за обработка на агенти. **Прогнози за пазара на SLM агенти**: Според последни изследвания, автоматизацията, задвижвана от агенти, може да елиминира 40–60% от повтарящите се когнитивни задачи в корпоративните работни потоци до 2027 г., като SLM водят тази трансформация благодарение на тяхната икономичност и гъвкавост при разгръщане. **Технологични тенденции в SLM агентите**: - **Специализирани SLM агенти**: Модели, обучени за конкретни задачи и индустрии - **Edge изчисления за агенти**: Подобрени възможности на агенти на устройства с намалена латентност и подобрена поверителност - **Оркестрация на агенти**: По-добра координация между множество SLM агенти с динамично маршрутизиране и балансиране на натоварването - **Демократизация**: Гъвкавостта на SLM позволява по-широко участие в разработката на агенти в различни организации ## Започване с SLM агенти ### Стъпка 1: Настройка на среда за Microsoft Agent Framework **Инсталиране на зависимости**: ```bash # Install Microsoft Agent Framework pip install microsoft-agent-framework # Install Foundry Local SDK for edge deployment pip install foundry-local-sdk # Install additional dependencies for edge agents pip install openai asyncio ``` **Инициализиране на Foundry Local**: ```bash # Start Foundry Local service foundry service start # Load default model for agent development foundry model run phi-4-mini ``` ### Стъпка 2: Избор на SLM за приложения на агенти Популярни опции за Microsoft Agent Framework: - **Microsoft Phi-4 Mini (3.8B)**: Отличен за общи задачи на агенти с балансирана производителност - **Qwen2.5-0.5B (0.5B)**: Ултра-ефективен за прости агенти за маршрутизиране и класификация - **Qwen2.5-Coder-0.5B (0.5B)**: Специализиран за задачи, свързани с код - **Phi-4 (7B)**: Напреднало разсъждение за сложни Edge сценарии, когато ресурсите позволяват ### Стъпка 3: Създаване на първия агент с Microsoft Agent Framework **Основна настройка на агент**: ```python from microsoft_agent_framework import Agent, Config from foundry_local import FoundryLocalManager # Initialize Foundry Local connection foundry = FoundryLocalManager("phi-4-mini") # Create agent configuration config = Config( name="my-first-agent", model_provider="foundry-local", model_alias="phi-4-mini", offline_mode=True ) # Create and configure agent agent = Agent( config=config, model_endpoint=foundry.endpoint, api_key=foundry.api_key ) # Define a simple tool @agent.tool def get_current_time() -> str: """Get the current time.""" from datetime import datetime return datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Test the agent response = agent.chat("What time is it?") print(response) ``` ### Стъпка 4: Определяне на обхвата и изискванията на агента Започнете с фокусирани, добре дефинирани приложения на агенти, използвайки Microsoft Agent Framework: - **Агенти за един домейн**: Обслужване на клиенти ИЛИ планиране ИЛИ изследвания - **Ясни цели на агента**: Специфични, измерими цели за производителността на агента - **Ограничена интеграция на инструменти**: Максимум 3-5 инструмента за първоначално разгръщане на агента - **Определени граници на агента**: Ясни пътища за ескалация при сложни сценарии - **Дизайн, ориентиран към Edge**: Приоритизирайте офлайн функционалността и локалната обработка ### Стъпка 5: Внедряване на Edge разгръщане с Microsoft Agent Framework **Конфигурация на ресурси**: ```python from microsoft_agent_framework import ResourceConfig # Configure for edge deployment resource_config = ResourceConfig( max_memory_usage="2GB", max_concurrent_agents=2, model_cache_size="1GB", auto_unload_idle_models=True, power_management=True ) agent = Agent( config=config, resource_limits=resource_config ) ``` **Внедряване на мерки за безопасност за Edge агенти**: - **Локална проверка на входа**: Проверявайте заявките без зависимост от облака - **Офлайн филтриране на изхода**: Уверете се, че отговорите отговарят на стандартите за качество локално - **Контроли за сигурност на Edge**: Внедрете сигурност без необходимост от интернет връзка - **Локален мониторинг**: Проследявайте производителността и маркирайте проблеми чрез телеметрия на Edge ### Стъпка 6: Измерване и оптимизация на производителността на Edge агенти - **Процент на завършване на задачи на агенти**: Проследявайте успеха в офлайн сценарии - **Време за отговор на агенти**: Осигурете време за отговор под секунда за разгръщане на Edge - **Използване на ресурси**: Проследявайте паметта, CPU и използването на батерията на Edge устройства - **Икономичност**: Сравнете разходите за разгръщане на Edge с алтернативи, базирани на облак - **Офлайн надеждност**: Измерете производителността на агента по време на прекъсвания на мрежата ## Основни изводи за внедряване на SLM агенти 1. **SLM са достатъчни за агенти**: За повечето задачи на агенти малките модели се представят толкова добре, колкото големите, като предлагат значителни предимства 2. **Икономичност в агентите**: 10-30 пъти по-евтино е да се използват SLM агенти, което ги прави икономически изгодни за широко разгръщане 3. **Специализацията работи за агенти**: Фино настроените SLM често превъзхождат общите LLM в специфични приложения на агенти 4. **Хибридна архитектура на агенти**: Използвайте SLM за рутинни задачи на агенти, LLM за сложни разсъждения, когато е необходимо 5. **Microsoft Agent Framework позволява производствено разгръщане**: Осигурява инструменти от корпоративен клас за изграждане, разгръщане и управление на Edge агенти 6. **Принципи на дизайн, ориентиран към Edge**: Агенти, способни на офлайн работа с локална обработка, осигуряват поверителност и надеждност 7. **Интеграция на Foundry Local**: Безпроблемна връзка между Microsoft Agent Framework и локалното извеждане на модели 8. **Бъдещето е SLM агенти**: Малките езикови модели с производствени рамки са бъдещето на агентния AI, позволявайки демократизирано и ефективно разгръщане на агенти ## Референции и допълнителна литература ### Основни изследователски статии и публикации #### AI агенти и агентни системи - **"Language Agents as Optimizable Graphs"** (2024) - Основни изследвания върху архитектурата и оптимизацията на агенти - Автори: Wenyue Hua, Lishan Yang, и др. - Линк: https://arxiv.org/abs/2402.16823 - Основни изводи: Дизайн на агенти, базиран на графи, и стратегии за оптимизация - **"The Rise and Potential of Large Language Model Based Agents"** (2023) - Автори: Zhiheng Xi, Wenxiang Chen, и др. - Линк: https://arxiv.org/abs/2309.07864 - Основни изводи: Обширен преглед на възможностите и приложенията на агенти, базирани на LLM - **"Cognitive Architectures for Language Agents"** (2024) - Автори: Theodore Sumers, Shunyu Yao, и др. - Линк: https://arxiv.org/abs/2309.02427 - Основни изводи: Когнитивни рамки за проектиране на интелигентни агенти #### Малки езикови модели и оптимизация - **"Phi-3 Technical Report: A Highly Capable Language Model Locally on Your Phone"** (2024) - Автори: Microsoft Research Team - Линк: https://arxiv.org/abs/2404.14219 - Основни изводи: Принципи на дизайн на SLM и стратегии за мобилно разгръщане - **"Qwen2.5 Technical Report"** (2024) - Автори: Alibaba Cloud Team - Линк: https://arxiv.org/abs/2407.10671 - Основни изводи: Напреднали техники за обучение на SLM и оптимизация на производителността - **"TinyLlama: An Open-Source Small Language Model"** (2024) - Автори: Peiyuan Zhang, Guangtao Zeng, и др. - Линк: https://arxiv.org/abs/2401.02385 - Основни изводи: Ултра-компактен дизайн на модели и ефективност на обучението ### Официална документация и рамки #### Microsoft Agent Framework - **Официална документация**: https://docs.microsoft.com/en-us/azure/ai-services/agents/ - **GitHub хранилище**: https://github.com/microsoft/agent-framework #### Foundry Local - **Основно хранилище**: https://github.com/microsoft/foundry-local - **Документация**: https://github.com/microsoft/foundry-local/blob/main/docs/README.md #### VLLM - **Основно хранилище**: https://github.com/vllm-project/vllm - **Документация**: https://docs.vllm.ai/ #### Ollama - **Официален сайт**: https://ollama.ai/ - **GitHub хранилище**: https://github.com/ollama/ollama ### Рамки за оптимизация на модели #### Llama.cpp - **Хранилище**: https://github.com/ggml-org/llama.cpp #### Microsoft Olive - **Документация**: https://microsoft.github.io/Olive/ - **GitHub хранилище**: https://github.com/microsoft/Olive #### OpenVINO - **Официален сайт**: https://docs.openvino.ai/ #### Apple MLX - **Хранилище**: https://github.com/ml-explore/mlx ### Отраслови доклади и пазарен анализ #### Изследвания на пазара на AI агенти - **"The State of AI Agents 2025"** - McKinsey Global Institute - Линк: https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights/ai-agents-2025 - Основни изводи: Тенденции на пазара и модели на приемане в предприятията #### Технически бенчмаркове - **"Edge AI Inference Benchmarks"** - MLPerf - Линк: https://mlcommons.org/en/inference-edge/ - Основни изводи: Стандартизирани показатели за производителност за разгръщане на Edge ### Стандарти и спецификации #### Формати на модели и стандарти - **ONNX (Open Neural Network Exchange)**: https://onnx.ai/ - Формат на модел за съвместимост на различни платформи - **GGUF спецификация**: https://github.com/ggerganov/ggml/blob/master/docs/gguf.md - Квантизиран формат на модел за изводи на CPU - **OpenAI API спецификация**: https://platform.openai.com/docs/api-reference - Стандартен API формат за интеграция на езикови модели #### Сигурност и съответствие - **NIST AI Risk Management Framework**: https://www.nist.gov/itl/ai-risk-management-framework - **ISO/IEC 23053:2022 - AI Systems**: Рамка за AI системи и безопасност - **IEEE стандарти за AI**: https://standards.ieee.org/industry-connections/ai/ Преходът към агенти, задвижвани от SLM, представлява фундаментална промяна в начина, по който подхождаме към разгръщането на AI. Microsoft Agent Framework, комбиниран с локални платформи и ефективни малки езикови модели, предоставя цялостно решение за изграждане на агенти, готови за производство, които работят ефективно в Edge среди. Като се фокусираме върху ефективността, специализацията и практическата полезност, този технологичен стек прави AI агентите по-достъпни, икономични и ефективни за реални приложения във всяка индустрия и среда за Edge изчисления. Докато напредваме през 2025 г., комбинацията от все по-способни малки модели, усъвършенствани рамки за агенти като Microsoft Agent Framework и надеждни платформи за разгръщане на Edge ще отключи нови възможности за автономни системи, които могат да работят ефективно на Edge устройства, като същевременно поддържат поверителност, намаляват разходите и предоставят изключителни потребителски --- **Отказ от отговорност**: Този документ е преведен с помощта на AI услуга за превод [Co-op Translator](https://github.com/Azure/co-op-translator). Въпреки че се стремим към точност, моля, имайте предвид, че автоматизираните преводи може да съдържат грешки или неточности. Оригиналният документ на неговия роден език трябва да се счита за авторитетен източник. За критична информация се препоръчва професионален човешки превод. Ние не носим отговорност за каквито и да е недоразумения или погрешни интерпретации, произтичащи от използването на този превод.