Moduł 5: Modele językowe i generatywna AI
🎯 Cele modułu
- Wdrażanie i konfiguracja dużych modeli językowych (LLM)
- Zaawansowana inżynieria promptów i dostrajanie modeli
- Implementacja RAG (Retrieval Augmented Generation) systemów
- Budowa inteligentnych asystentów AI
Sesja 13: Wdrażanie dużych modeli językowych (14.10.2025)
🧠 Architektura dużych modeli językowych
Podstawy LLM
PRZEGLĄD ARCHITEKTURY TRANSFORMER:
TEKST WEJŚCIOWY → TOKENIZACJA → EMBEDDING → WARSTWY ATTENTION → GENEROWANIE WYJŚCIA
KLUCZOWE KOMPONENTY:
1. TOKENIZACJA:
- Dzielenie tekstu na tokeny
- Zarządzanie słownictwem (BPE, WordPiece)
- Tokeny specjalne ([CLS], [SEP], [MASK])
2. EMBEDDINGI:
- Embeddingi tokenów (reprezentacja słownictwa)
- Embeddingi pozycji (kolejność w sekwencji)
- Embeddingi segmentów (dla zadań wielosekwencyjnych)
3. MECHANIZM ATTENTION:
- Self-attention (relacje tokenów w sekwencji)
- Multi-head attention (różne podprzestrzenie reprezentacji)
- Scaled dot-product attention (optymalizacja wydajności)
4. SIECI FEED-FORWARD:
- Transformacje pozycyjne
- Nieliniowe funkcje aktywacji
- Połączenia resztkowe i normalizacja warstw
Konfiguracja Azure AI Foundry
Azure AI Foundry umożliwia tworzenie inteligentnych, adaptowalnych agentów AI, którzy automatyzują zadania, integrują się z aplikacjami i usprawniają doświadczenia użytkowników.
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.core.credentials import AzureKeyCredential
# Konfiguracja klienta Azure AI Foundry
credential = DefaultAzureCredential() # lub AzureKeyCredential("your-api-key")
project_client = AIProjectClient(
endpoint="https://your-project.cognitiveservices.azure.com/",
credential=credential,
subscription_id="your-subscription-id",
resource_group_name="your-resource-group",
project_name="your-project-name"
)
def create_ai_agent(agent_name, instructions, model_deployment):
"""Tworzenie agenta AI w Azure AI Foundry"""
agent_config = {
"name": agent_name,
"instructions": instructions,
"model": model_deployment,
"tools": [
{"type": "file_search"}, # Wyszukiwanie w plikach
{"type": "code_interpreter"}, # Interpreter kodu
{"type": "function", "function": { # Funkcje niestandardowe
"name": "get_weather",
"description": "Pobierz prognozę pogody dla miasta",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string", "description": "Nazwa miasta"}
}
}
}}
]
}
agent = project_client.agents.create_agent(**agent_config)
return agent
def deploy_language_model(model_name, deployment_name):
"""Wdrożenie LLM w Azure AI Foundry"""
deployment_config = {
"model": model_name, # np. "gpt-4", "gpt-4o-mini"
"deployment_name": deployment_name,
"sku": {
"name": "Standard",
"capacity": 10 # Pojemność TPM (tokeny na minutę)
}
}
deployment = project_client.deployments.create(**deployment_config)
return f"Wdrożenie {deployment_name} utworzone pomyślnie w AI Foundry"
def test_agent_interaction(agent_id, message):
"""Testowanie interakcji z agentem AI"""
# Utworzenie wątku konwersacji
thread = project_client.agents.create_thread()
# Dodanie wiadomości do wątku
project_client.agents.create_message(
thread_id=thread.id,
role="user",
content=message
)
# Uruchomienie agenta
run = project_client.agents.create_run(
thread_id=thread.id,
assistant_id=agent_id
)
# Oczekiwanie na completion
while run.status in ["queued", "in_progress"]:
run = project_client.agents.get_run(
thread_id=thread.id,
run_id=run.id
)
time.sleep(1)
# Pobranie odpowiedzi
messages = project_client.agents.list_messages(thread_id=thread.id)
return messages.data[0].content[0].text.value
🎯 Wybór modelu i optymalizacja
Wybór odpowiedniego modelu dla przypadku użycia
PORÓWNANIE MODELI - AZURE OPENAI:
GPT-4 TURBO:
✓ Najwyższe możliwości rozumowania
✓ Obsługa złożonych zadań
✓ Okno kontekstu 128k
✗ Wyższy koszt i opóźnienia
NAJLEPSZE DO: Złożone analizy, pisanie kreatywne, generowanie kodu
GPT-3.5 TURBO:
✓ Szybkie czasy odpowiedzi
✓ Opłacalne
✓ Okno kontekstu 16k
✓ Dobre do większości zadań
NAJLEPSZE DO: Aplikacje czatu, proste generowanie treści
GPT-4 VISION:
✓ Multimodalne (tekst + obrazy)
✓ Rozumienie wizualne
✓ Analiza wykresów i diagramów
NAJLEPSZE DO: Analiza dokumentów, rozumienie treści wizualnych
TEXT-EMBEDDING-ADA-002:
✓ Wysokiej jakości embeddingi
✓ Limit wejścia 8192 tokeny
✓ Opłacalne dla dużych wolumenów
NAJLEPSZE DO: Wyszukiwanie semantyczne, grupowanie, rekomendacje
Enterprise optimization w Azure AI Foundry
Po opanowaniu podstaw multimodalnych systemów w module 3, przechodzimy do zaawansowanego zarządzania LLM w środowisku enterprise.
class EnterpriseAIFoundryManager:
"""Enterprise-grade zarządzanie agentami w Azure AI Foundry"""
def __init__(self, project_client):
self.project_client = project_client
self.agent_pool = {}
self.performance_metrics = {}
self.cost_tracker = {}
def create_specialized_agent(self, specialty, model_config):
"""Tworzenie wyspecjalizowanych agentów enterprise"""
agent_configs = {
"content_creator": {
"instructions": "Ekspert tworzenia treści edukacyjnych...",
"tools": ["file_search", "code_interpreter"],
"model": "gpt-4o"
},
"data_analyst": {
"instructions": "Analityk danych edukacyjnych...",
"tools": ["code_interpreter", "function_calling"],
"model": "gpt-4-turbo"
},
"quality_assessor": {
"instructions": "Oceniacz jakości materiałów...",
"tools": ["file_search", "function_calling"],
"model": "gpt-4o"
}
}
config = agent_configs.get(specialty, agent_configs["content_creator"])
agent = self.project_client.agents.create_agent(
model=config["model"],
name=f"Enterprise-{specialty}",
instructions=config["instructions"],
tools=config["tools"]
)
self.agent_pool[specialty] = agent
return agent
def orchestrate_multi_agent_workflow(self, task, agents_needed):
"""Orkiestracja współpracy między agentami"""
workflow_results = {}
for agent_type in agents_needed:
if agent_type in self.agent_pool:
# Delegacja zadania do odpowiedniego agenta
result = self._delegate_task(agent_type, task)
workflow_results[agent_type] = result
# Agregacja wyników przez głównego agenta
final_result = self._aggregate_results(workflow_results)
# Tracking kosztów i wydajności
self._track_workflow_metrics(agents_needed, workflow_results)
return final_result
def optimize_token_usage(self):
"""Optymalizacja wykorzystania tokenów w skali enterprise"""
optimization_strategies = {
"prompt_compression": "Kompresja długich promptów",
"response_caching": "Cache'owanie podobnych zapytań",
"model_routing": "Routing do optymalnych modeli",
"batch_processing": "Przetwarzanie wsadowe"
}
return optimization_strategies
Sesja 14: Advanced Agent Engineering w Azure AI Foundry (16.10.2025)
🧠 Od prompt engineering do agent engineering
Po opanowaniu podstaw multimodalnych systemów, przechodzimy do enterprise agent development - zarządzania zespołami agentów AI w skali produkcyjnej.
🎛️ Advanced Agent Design Patterns
Enterprise Agent Architecture
AZURE AI FOUNDRY AGENT ECOSYSTEM:
┌─────────────────────────────────────────────────────────────┐
│ AGENT ORCHESTRATION LAYER │
├─────────────────────────────────────────────────────────────┤
│ Master Agent (Supervisor) │
│ ├─ Task routing and delegation │
│ ├─ Quality assurance and validation │
│ ├─ Error handling and recovery │
│ └─ Performance monitoring and optimization │
├─────────────────────────────────────────────────────────────┤
│ Specialized Worker Agents │
│ ├─ ContentCreator → Materials generation │
│ ├─ QualityAnalyzer → Content evaluation │
│ ├─ DataProcessor → Analytics and insights │
│ ├─ CommunicationBot → Stakeholder engagement │
│ └─ ComplianceChecker → Standards validation │
├─────────────────────────────────────────────────────────────┤
│ Shared Resources │
│ ├─ Knowledge Base (File Search) │
│ ├─ Code Execution Environment │
│ ├─ External API Integrations │
│ └─ Monitoring and Logging │
└─────────────────────────────────────────────────────────────┘
Agent Specialization Framework
Master Agent Configuration:
SUPERVISOR AGENT SYSTEM PROMPT:
ROLA: Master Coordinator dla systemu edukacyjnego AI
ODPOWIEDZIALNOŚCI:
1. TASK ROUTING: Delegowanie zadań do wyspecjalizowanych agentów
2. QUALITY CONTROL: Walidacja wyników przed dostarczeniem
3. WORKFLOW MANAGEMENT: Koordynacja przepływów wieloetapowych
4. ERROR RECOVERY: Obsługa błędów i alternative pathways
5. PERFORMANCE OPTIMIZATION: Monitorowanie i usprawnienie systemu
DOSTĘPNI AGENCI:
- ContentCreator: Generowanie materiałów edukacyjnych
- QualityAnalyzer: Ocena jakości treści
- DataProcessor: Analiza danych i metryk
- CommunicationBot: Komunikacja z interesariuszami
- ComplianceChecker: Sprawdzanie zgodności ze standardami
DECISION FRAMEWORK:
1. Analizuj typ zadania i wymagania
2. Wybierz optymalnego agenta lub kombinację agentów
3. Monitoruj postęp i jakość wykonania
4. Agreguj wyniki w spójny deliverable
5. Zapewnij feedback loops dla ciągłego doskonalenia
QUALITY GATES:
- Każdy output podlega review przed dostarczeniem
- Automatyczna walidacja zgodności ze standardami
- Human-in-the-loop dla krytycznych decyzji
Szablony promptów klasy produkcyjnej
class PromptTemplateLibrary:
def __init__(self):
self.templates = {}
self.performance_metrics = {}
def create_analysis_prompt(self, domain, complexity_level):
"""Generowanie promptu analitycznego dla konkretnej dziedziny"""
if complexity_level == "basic":
return f"""
Jesteś ekspertem-analitykiem {domain} z ponad 10-letnim doświadczeniem.
Przeanalizuj następujące dane i podaj:
1. Kluczowe wnioski (maksymalnie 3 punkty)
2. Główne trendy lub wzorce
3. Praktyczne rekomendacje
Dane do analizy:
{{data}}
Sformatuj swoją odpowiedź jako ustrukturyzowany JSON:
{{
"insights": ["wniosek1", "wniosek2", "wniosek3"],
"trends": ["trend1", "trend2"],
"recommendations": ["rek1", "rek2"]
}}
"""
elif complexity_level == "advanced":
return f"""
Jesteś starszym konsultantem {domain} z głęboką wiedzą analityczną.
Wykonaj kompleksową analizę dostarczonych danych:
RAMY ANALITYCZNE:
1. Analiza opisowa: Co się stało?
2. Analiza diagnostyczna: Dlaczego to się stało?
3. Analiza predyktywna: Co może się stać dalej?
4. Analiza preskryptywna: Co powinniśmy zrobić?
DANE WEJŚCIOWE:
{{data}}
OGRANICZENIA:
- Opieraj wnioski na dowodach z danych
- Kwantyfikuj poziomy pewności dla przewidywań
- Zapewnij alternatywne scenariusze
- Uwzględnij ocenę ryzyka
FORMAT WYJŚCIA: Ustrukturyzowany raport z streszczeniem wykonawczym
"""
def create_generation_prompt(self, content_type, audience, tone):
"""Generowanie promptu tworzenia treści"""
base_prompt = f"""
Stwórz {content_type} dla {audience} używając tonu {tone}.
WYMAGANIA TREŚCI:
- Jasny i angażujący język odpowiedni dla docelowej grupy
- Dokładne i dobrze zbadane informacje
- Właściwa struktura i formatowanie
- Wezwanie do działania tam gdzie to właściwe
STANDARDY JAKOŚCI:
- Faktyczna dokładność (zweryfikuj wszystkie twierdzenia)
- Oryginalność (unikaj ogólnikowych treści)
- Czytelność (odpowiednia dla poziomu odbiorców)
- Optymalizacja SEO (naturalna integracja słów kluczowych)
TEMAT: {{topic}}
DODATKOWY KONTEKST: {{context}}
Wygeneruj treść spełniającą wszystkie powyższe wymagania.
"""
return base_prompt
🔧 Dostrajanie modelu i dostosowywanie
Strategie fine-tuningu
PODEJŚCIA DO FINE-TUNINGU:
1. INŻYNIERIA PROMPTÓW (Bez zmian modelu):
- Najszybsza implementacja
- Brak dodatkowych kosztów
- Ograniczone dostosowywanie
- Dobre dla: Ogólnych ulepszeń
2. FEW-SHOT LEARNING (Przykłady w promptcie):
- Umiarkowane dostosowywanie
- Bez konieczności trenowania
- Ograniczenia okna kontekstu
- Dobre dla: Spójności stylu i formatu
3. FINE-TUNING (Rzeczywiste trenowanie modelu):
- Wysokie dostosowywanie
- Wymaga danych treningowych
- Dodatkowe koszty
- Dobre dla: Aplikacji dziedzinowych
4. RETRIEVAL AUGMENTED GENERATION (RAG):
- Dynamiczne wstrzykiwanie wiedzy
- Aktualizacje informacji w czasie rzeczywistym
- Umiarkowana złożoność
- Dobre dla: Aplikacji intensywnych wiedzy
Implementacja fine-tuningu Azure OpenAI
import json
from typing import List, Dict
def prepare_fine_tuning_data(examples: List[Dict]):
"""Przygotowanie danych treningowych dla fine-tuningu Azure OpenAI"""
formatted_data = []
for example in examples:
formatted_example = {
"messages": [
{"role": "system", "content": example["system_message"]},
{"role": "user", "content": example["user_input"]},
{"role": "assistant", "content": example["expected_output"]}
]
}
formatted_data.append(formatted_example)
# Zapisz jako plik JSONL
with open("training_data.jsonl", "w", encoding="utf-8") as f:
for item in formatted_data:
f.write(json.dumps(item, ensure_ascii=False) + "\n")
return "training_data.jsonl"
def start_fine_tuning_job(training_file_path, model_name):
"""Uruchomienie zadania fine-tuningu w Azure OpenAI"""
# Przesłanie pliku treningowego
training_file = openai.File.create(
file=open(training_file_path, "rb"),
purpose="fine-tune"
)
# Utworzenie zadania fine-tuningu
fine_tuning_job = openai.FineTuningJob.create(
training_file=training_file.id,
model=model_name,
hyperparameters={
"n_epochs": 3,
"batch_size": 1,
"learning_rate_multiplier": 0.1
}
)
return fine_tuning_job.id
Sesja 15: Enterprise RAG i Agent Ecosystems (21.10.2025)
🏗️ Native RAG w Azure AI Foundry
Nowoczesne podejście: Agent-based RAG
Przejście od tradycyjnych systemów RAG do agent-based knowledge systems w Azure AI Foundry, gdzie inteligentne agenty zarządzają wiedzą i kontekstem.
AZURE AI FOUNDRY NATIVE RAG ARCHITECTURE:
USER QUERY → AI FOUNDRY AGENT → INTELLIGENT KNOWLEDGE RETRIEVAL → CONTEXTUAL RESPONSE
↓ ↓ ↓
[Agent Memory] [File Search Tool] [Grounded Output]
[Conversation] [Vector Search] [Source Attribution]
[Context Mgmt] [Hybrid Search] [Quality Validation]
ENTERPRISE RAG COMPONENTS w AI Foundry:
1. INTELLIGENT AGENTS:
├─ Knowledge Agent → Zarządzanie bazą wiedzy
├─ Retrieval Agent → Inteligentne wyszukiwanie
├─ Synthesis Agent → Łączenie informacji
└─ Quality Agent → Walidacja odpowiedzi
2. NATIVE TOOLS:
├─ File Search → Wbudowane wyszukiwanie semantyczne
├─ Code Interpreter → Analiza danych i obliczeń
├─ Function Calling → Integracje zewnętrzne
└─ Web Search → Aktualne informacje
3. KNOWLEDGE MANAGEMENT:
├─ Document Upload → Automatyczne indeksowanie
├─ Vector Storage → Embeddingi w chmurze
├─ Metadata Enrichment → Automatyczne tagowanie
└─ Version Control → Śledzenie zmian w dokumentach
Implementacja Enterprise RAG Agent
Knowledge Management Agent w AI Foundry:
ENTERPRISE KNOWLEDGE AGENT CONFIGURATION:
Agent Name: "KnowledgeManager"
Model: GPT-4o
Tools: ✓ File Search, ✓ Code Interpreter, ✓ Function Calling
System Prompt:
"ENTERPRISE KNOWLEDGE MANAGEMENT SYSTEM
JESTEŚ: Inteligentnym zarządcą wiedzy organizacyjnej
PRIMARY FUNCTIONS:
1. DOCUMENT INTELLIGENCE:
- Automatyczne indeksowanie przesłanych dokumentów
- Ekstrakcja metadanych i kluczowych tematów
- Tworzenie semantic knowledge graphs
- Identyfikacja duplikatów i sprzecznych informacji
2. INTELLIGENT RETRIEVAL:
- Hybrydowe wyszukiwanie (semantic + keyword)
- Kontekstowe filtrowanie wyników
- Ranking based on relevance + recency + authority
- Cross-document connection discovery
3. QUALITY ASSURANCE:
- Weryfikacja faktów między źródłami
- Identyfikacja potencjalnych hallucinations
- Confidence scoring dla odpowiedzi
- Source attribution i citation management
4. ADAPTIVE LEARNING:
- Monitoring user feedback on answers
- Iterative improvement of retrieval strategies
- Knowledge gap identification
- Automatic suggestion for content updates
KNOWLEDGE DOMAINS:
- Curriculum standards i requirements
- Best practices w edukacji
- Regulatory compliance
- Organizational procedures
- Research papers i metodologie
OUTPUT STANDARDS:
- Always include source attribution
- Provide confidence scores
- Offer alternative perspectives when available
- Flag outdated or conflicting information"
Native RAG Implementation w Azure AI Foundry
Zarządzanie wiedzą bez external dependencies:
Azure AI Foundry oferuje natywne możliwości RAG przez wbudowane narzędzie File Search, eliminując potrzebę zewnętrznych bibliotek jak LangChain.
# Azure AI Foundry Native RAG - simplified approach
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
class AIFoundryRAGSystem:
"""Natywny system RAG wykorzystujący wbudowane możliwości AI Foundry"""
def __init__(self, project_endpoint):
self.project_client = AIProjectClient(
endpoint=project_endpoint,
credential=DefaultAzureCredential()
)
self.knowledge_agent = None
def setup_knowledge_agent(self):
"""Tworzenie agenta z natywnym File Search"""
self.knowledge_agent = self.project_client.agents.create_agent(
model="gpt-4o",
name="EnterpriseKnowledgeAgent",
instructions="""
Jesteś ekspertowym systemem zarządzania wiedzą organizacyjną.
NATIVE CAPABILITIES:
- File Search: Automatyczne wyszukiwanie w przesłanych dokumentach
- Semantic Understanding: Rozumienie kontekstu i intent
- Source Attribution: Zawsze podawaj źródła informacji
- Quality Validation: Oceniaj pewność odpowiedzi
WORKFLOW:
1. Analizuj pytanie użytkownika
2. Przeszukaj bazę wiedzy używając File Search
3. Syntetyzuj odpowiedź z wielu źródeł
4. Podaj źródła i poziom pewności
5. Zasugeruj related topics lub follow-up questions
QUALITY STANDARDS:
- Zawsze podawaj źródła
- Jasno oznaczaj poziom pewności (0-100%)
- Flaguj sprzeczne informacje
- Sugeruj aktualizacje dla przestarzałych danych
""",
tools=[
{"type": "file_search"},
{"type": "code_interpreter"}
]
)
return self.knowledge_agent
def upload_knowledge_base(self, file_paths):
"""Upload dokumentów do bazy wiedzy"""
uploaded_files = []
for file_path in file_paths:
with open(file_path, "rb") as file:
uploaded_file = self.project_client.agents.files.upload(
file=file,
purpose="assistants"
)
uploaded_files.append(uploaded_file)
# Aktualizacja agenta z nymi plikami
self.project_client.agents.update_agent(
agent_id=self.knowledge_agent.id,
tool_resources={
"file_search": {
"file_ids": [f.id for f in uploaded_files]
}
}
)
return f"Przesłano {len(uploaded_files)} dokumentów do bazy wiedzy"
def query_knowledge(self, question, context=None):
"""Zapytanie do systemu RAG z natywnym File Search"""
# Utworzenie wątku konwersacji
thread = self.project_client.agents.threads.create()
# Konstrukcja zapytania z kontekstem
enhanced_query = question
if context:
enhanced_query = f"Kontekst: {context}\n\nPytanie: {question}"
# Wysłanie zapytania
message = self.project_client.agents.messages.create(
thread_id=thread.id,
role="user",
content=enhanced_query
)
# Uruchomienie agenta
run = self.project_client.agents.runs.create_and_process(
thread_id=thread.id,
agent_id=self.knowledge_agent.id
)
# Pobranie odpowiedzi
messages = self.project_client.agents.messages.list(thread_id=thread.id)
latest_response = messages.data[0]
return {
"answer": latest_response.content[0].text.value,
"thread_id": thread.id, # Dla kontynuacji rozmowy
"run_status": run.status,
"sources": self._extract_sources(latest_response)
}
def _extract_sources(self, message):
"""Wydobywanie źródeł z odpowiedzi agenta"""
# AI Foundry automatycznie dodaje source attribution
# gdy używa File Search tool
sources = []
if hasattr(message, 'annotations'):
for annotation in message.annotations:
if annotation.type == "file_citation":
sources.append({
"file_id": annotation.file_citation.file_id,
"quote": annotation.text
})
return sources
🏗️ Enterprise Agent Ecosystem
Production-grade Multi-Agent Architecture
Finalizujemy kurs przez budowę kompletnego ekosystemu agentów enterprise w Azure AI Foundry, łączącego wszystkie poznane technologie.
class EnterpriseEducationPlatform:
"""Kompletna platforma edukacyjna oparta na AI Foundry"""
def __init__(self, project_endpoint):
self.project_client = AIProjectClient(
endpoint=project_endpoint,
credential=DefaultAzureCredential()
)
self.agent_ecosystem = {}
def initialize_agent_ecosystem(self):
"""Inicjalizacja kompletnego ekosystemu agentów"""
# Agent Supervisor - orchestration layer
supervisor = self.project_client.agents.create_agent(
model="gpt-4o",
name="EducationSupervisor",
instructions="""
Master Coordinator dla enterprise education platform.
Zarządzasz zespołem wyspecjalizowanych agentów:
- ContentCreator: Materiały edukacyjne
- QualityAnalyzer: Ocena jakości
- SpeechProcessor: Analiza audio/transkrypcja
- VisionAnalyzer: Analiza obrazów/dokumentów
- DataInsights: Analytics i raporty
Deleguj zadania, monitoruj jakość, agreguj wyniki.
""",
tools=[{"type": "function_calling"}]
)
# Specialized Worker Agents
agents = {
"content_creator": self._create_content_agent(),
"quality_analyzer": self._create_quality_agent(),
"speech_processor": self._create_speech_agent(),
"vision_analyzer": self._create_vision_agent(),
"data_insights": self._create_analytics_agent()
}
self.agent_ecosystem = {
"supervisor": supervisor,
**agents
}
return "Enterprise Agent Ecosystem initialized"
def _create_content_agent(self):
"""Agent do tworzenia materiałów edukacyjnych"""
return self.project_client.agents.create_agent(
model="gpt-4o",
name="ContentCreator",
instructions="""
Ekspert tworzenia wysokiej jakości materiałów edukacyjnych.
Specjalizacje:
- Planowanie lekcji i curriculum
- Generowanie quizów i testów
- Materiały interaktywne
- Adaptacja do różnych stylów uczenia
Zawsze uwzględniaj pedagogiczne best practices.
""",
tools=[
{"type": "file_search"},
{"type": "code_interpreter"}
]
)
def process_complex_educational_task(self, task_description):
"""Przetwarzanie złożonych zadań edukacyjnych przez ecosystem"""
# Supervisor analizuje zadanie i deleguje
thread = self.project_client.agents.threads.create()
# Wiadomość dla supervisora
message = self.project_client.agents.messages.create(
thread_id=thread.id,
role="user",
content=f"""
Zadanie do wykonania: {task_description}
Przeanalizuj zadanie i:
1. Określ, które agenty są potrzebne
2. Zaplanuj workflow między agentami
3. Zdefiniuj kryteria sukcesu
4. Rozpocznij wykonanie
"""
)
# Uruchomienie supervisora
run = self.project_client.agents.runs.create_and_process(
thread_id=thread.id,
agent_id=self.agent_ecosystem["supervisor"].id
)
# Pobranie planu wykonania
messages = self.project_client.agents.messages.list(thread_id=thread.id)
execution_plan = messages.data[0].content[0].text.value
return {
"execution_plan": execution_plan,
"thread_id": thread.id,
"status": run.status
}
🎯 Final Project: Enterprise AI Education Platform
Kompletna implementacja w Azure AI Foundry
CAPSTONE PROJECT: Full-Scale Educational AI Platform
ENTERPRISE EDUCATIONAL AI ECOSYSTEM - FINAL IMPLEMENTATION:
PHASE 1: PLATFORM ARCHITECTURE (60 min)
├─ Azure AI Foundry Project setup
├─ Multi-agent ecosystem deployment
├─ Integration layer configuration
└─ Security i compliance setup
PHASE 2: CORE AGENTS DEPLOYMENT (90 min)
├─ Master Supervisor Agent
├─ Content Creation Agent (NLP + generation)
├─ Multimodal Analysis Agent (Speech + Vision)
├─ Quality Assurance Agent
└─ Analytics i Reporting Agent
PHASE 3: KNOWLEDGE BASE INTEGRATION (45 min)
├─ Document upload i indexing (File Search)
├─ Curriculum standards integration
├─ Best practices knowledge base
└─ Regulatory compliance documentation
PHASE 4: MULTIMODAL CAPABILITIES (60 min)
├─ Speech-to-Text integration (meetings/lectures)
├─ Vision analysis (documents/presentations)
├─ Real-time conversation analysis
└─ Multimodal content generation
PHASE 5: ENTERPRISE FEATURES (45 min)
├─ User access management (RBAC)
├─ Audit logging i monitoring
├─ Cost tracking i optimization
├─ Integration APIs (Teams/SharePoint)
└─ Production deployment checklist
DELIVERABLE: Fully functional enterprise AI platform
Live Implementation Workshop
3-Hour Hands-On Session: Budowa kompletnej platformy
Godzina 1: Foundation Setup
- Tworzenie Azure AI Foundry project
- Wdrożenie kluczowych modeli (GPT-4o, embeddings)
- Konfiguracja connections (Speech, Language Services)
- Podstawowa konfiguracja security
Godzina 2: Agent Development
- Implementacja Master Supervisor Agent
- Deploy specialized worker agents
- Konfiguracja tools i integrations
- Testing agent-to-agent communication
Godzina 3: End-to-End Testing
- Upload sample educational content
- Testing multimodal workflows
- Performance optimization
- Production readiness checklist
🏠 Zadania między sesjami
Zadanie 1: Personal Enterprise Platform (Tydzień 1)
- Zbuduj własną instancję enterprise platform
- Dostosuj agentów do swojej organizacji/dziedziny
- Zintegruj z rzeczywistymi dokumentami i procesami
- Udokumentuj deployment proces
Zadanie 2: Advanced Agent Orchestration (Tydzień 2)
- Rozszerz platform o dodatkowych agentów
- Zaimplementuj complex multi-step workflows
- Dodaj monitoring i analytics dashboards
- Optymalizuj performance i costs
Zadanie 3: Production Deployment (Tydzień 3)
- Przygotuj platform do production use
- Zaimplementuj enterprise security measures
- Stwórz user training materials
- Przeprowadź pilot deployment z real users
✅ Kryteria oceny modułu
Kompetencje enterprise-level
- Agent Ecosystem Management: Zarządzanie zespołami agentów ✓
- Production Deployment: Wdrażanie systemów enterprise ✓
- Integration Architecture: Łączenie z systemami organizacyjnymi ✓
- Performance Optimization: Optymalizacja kosztów i wydajności ✓
Kompetencje zaawansowane
- Multi-Agent Orchestration: Koordynacja współpracy agentów ✓
- Native RAG Implementation: Systemy wiedzy bez dependencies ✓
- Multimodal Integration: Łączenie text/speech/vision ✓
- Enterprise Security: RBAC, audit, compliance ✓
Portfolio końcowe
- Complete Enterprise Platform: Działający ecosystem w Azure AI Foundry
- Production Documentation: Kompletna dokumentacja deployment
- Training Materials: Materiały szkoleniowe dla użytkowników
- Case Study Report: Analiza implementacji i wyników
💡 Enterprise Best Practices
Production Deployment Considerations
AZURE AI FOUNDRY ENTERPRISE CHECKLIST:
PERFORMANCE & SCALABILITY:
├─ Auto-scaling configuration dla agentów
├─ Load balancing między multiple deployments
├─ Caching strategies dla frequently accessed content
├─ Async processing dla long-running tasks
└─ Token usage optimization i cost management
SECURITY & COMPLIANCE:
├─ RBAC configuration dla różnych user roles
├─ Data encryption in transit i at rest
├─ Audit logging dla wszystkich agent interactions
├─ PII detection i protection
└─ Compliance monitoring (GDPR, industry standards)
MONITORING & OBSERVABILITY:
├─ Agent performance metrics (response time, accuracy)
├─ User satisfaction tracking
├─ Cost monitoring i alerting
├─ Error tracking i alerting
└─ Usage analytics i reporting
GOVERNANCE & MANAGEMENT:
├─ Version control dla agent configurations
├─ Change management procedures
├─ Backup i disaster recovery
├─ Documentation i knowledge management
└─ Continuous improvement processes
📚 Zasoby produkcyjne
Azure AI Foundry Enterprise
- Enterprise deployment guide↗
- Security best practices↗
- Cost optimization strategies↗
- Monitoring i observability↗
Enterprise Integration
- Microsoft Teams integration patterns
- Power Platform connectors
- SharePoint knowledge management
- Azure Monitor dla production monitoring
Ongoing Learning
- Azure AI updates i new features
- Community best practices
- Industry case studies
- Certification pathways