Moduł 4: Native Search w Azure AI Foundry

🎯 Cele modułu

  • Opanowanie natywnych możliwości wyszukiwania w Azure AI Foundry
  • Budowa enterprise knowledge management systems
  • Implementacja intelligent document retrieval
  • Zaawansowane techniki semantic search bez external dependencies

Sesja 10: Native File Search w Azure AI Foundry (02.10.2025)

🚀 Przejście na natywne możliwości Azure AI Foundry

Po opanowaniu agent development w poprzednich modułach, skupiamy się na natywnych możliwościach wyszukiwania w Azure AI Foundry, eliminując potrzebę zewnętrznych narzędzi.

🔍 Native vs External Search Solutions

Porównanie podejść

EXTERNAL TOOLS (LangChain, Vector DBs)    vs    AZURE AI FOUNDRY NATIVE

KOMPLEKSNOŚĆ:                                   SIMPLICITY:
├─ Multiple dependencies                        ├─ Zero external dependencies
├─ Custom vector database setup                ├─ Automatic indexing
├─ Manual embedding management                  ├─ Built-in embeddings
├─ Complex integration code                     ├─ Single API call
└─ Maintenance overhead                         └─ Managed service

CAPABILITIES COMPARISON:
External: Pełna kontrola, ale wysosk overhead   Native: Managed capabilities, easy deployment
External: Custom embedding models              Native: Optimized embeddings out-of-box
External: Manual scaling                       Native: Auto-scaling
External: DIY monitoring                       Native: Built-in observability

AZURE AI FOUNDRY NATIVE ADVANTAGES:
✓ Automatic document indexing
✓ Semantic search out-of-the-box
✓ Zero-configuration embeddings
✓ Integrated with agent memory
✓ Built-in source attribution
✓ Enterprise security by default

WYSZUKIWANIE SEMANTYCZNE:
Zapytanie: "apple fruit nutrition"  
Wyniki: Dokumenty o jabłkach, owocach, wartościach odżywczych
Zaleta: Rozumie znaczenie, nie tylko słowa kluczowe

WYSZUKIWANIE WEKTOROWE:
Zapytanie: [0.2, -0.8, 0.1, ...] (785-wymiarowy wektor)
Wyniki: Dokumenty o podobnych embedding-ach semantycznych
Moc: Może znajdować koncepcyjnie powiązane treści

Modele embedding dla wyszukiwania semantycznego

SENTENCE TRANSFORMERS:
- all-MiniLM-L6-v2: Lekki, szybkie przetwarzanie
- all-mpnet-base-v2: Wyższa dokładność, wolniejszy
- multilingual-e5-large: Najlepszy dla polskich treści

OPENAI EMBEDDINGS:
- text-embedding-3-small: Ekonomiczny
- text-embedding-3-large: Maksymalna dokładność
- Ada-002: Starszy ale sprawdzony

AZURE OPENAI EMBEDDINGS:
- Te same modele co OpenAI
- Hosting zgodny z GDPR w Europie
- Funkcje bezpieczeństwa enterprise
- Integracja z ekosystemem Azure

🛠️ Implementacja Azure Wyszukiwanie semantyczne

Architektura usługi wyszukiwania

KOMPONENTY AZURE WYSZUKIWANIE SEMANTYCZNE:

ŹRÓDŁA DANYCH → INDEKSATORY → INDEKS WYSZUKIWANIA → KLIENT WYSZUKIWANIA

ŹRÓDŁA DANYCH:
- Azure Blob Storage (dokumenty, obrazy)
- Azure SQL Database (dane strukturalne)
- Cosmos DB (dokumenty JSON)  
- SharePoint Online (dokumenty firmowe)

INDEKSATORY:
- Automatyczne wydobywanie treści
- Wbudowane umiejętności kognitywne (OCR, rozpoznawanie encji)
- Niestandardowe umiejętności (modele AI, API)
- Planowanie i monitorowanie

INDEKS WYSZUKIWANIA:
- Definicje pól i typy
- Analizatory dla przetwarzania tekstu
- Profile oceniania dla trafności
- Aspekty i filtry dla nawigacji

KLIENT WYSZUKIWANIA:
- Punkty końcowe REST API
- SDK .NET/Python/JavaScript
- Składnia zapytań i operatory
- Ranking wyników i podświetlanie

Praktyczne: Budowanie indeksu wyszukiwania

from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import *

def create_knowledge_base_index():
    # Definiowanie schematu indeksu wyszukiwania
    fields = [
        SimpleField(name="id", type=SearchFieldDataType.String, key=True),
        SearchableField(name="title", type=SearchFieldDataType.String),
        SearchableField(name="content", type=SearchFieldDataType.String),
        SimpleField(name="category", type=SearchFieldDataType.String, filterable=True),
        SimpleField(name="lastModified", type=SearchFieldDataType.DateTimeOffset),
        SearchableField(name="contentVector", type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
                       searchable=True, vector_search_dimensions=1536, vector_search_profile_name="myHnswProfile")
    ]
    
    # Konfiguracja wyszukiwania wektorowego
    vector_search = VectorSearch(
        profiles=[VectorSearchProfile(
            name="myHnswProfile",
            algorithm_configuration_name="myHnsw"
        )],
        algorithms=[HnswAlgorithmConfiguration(name="myHnsw")]
    )
    
    # Tworzenie indeksu
    index = SearchIndex(
        name="knowledge-base",
        fields=fields,
        vector_search=vector_search,
        semantic_search=SemanticSearch(
            configurations=[SemanticConfiguration(
                name="default",
                prioritized_fields=SemanticPrioritizedFields(
                    title_field=SemanticField(field_name="title"),
                    content_fields=[SemanticField(field_name="content")]
                )
            )]
        )
    )
    
    return index

Sesja 11: Inteligentna analiza dokumentów (07.10.2025)

📄 Azure Form Recognizer & Document Intelligence

Proces przetwarzania dokumentów

PRZEPŁYW PRZETWARZANIA DOKUMENTÓW:

PRZESYŁANIE → PRZETWARZANIE WSTĘPNE → ANALIZA UKŁADU → WYDOBYWANIE TREŚCI → LOGIKA BIZNESOWA

PRZETWARZANIE WSTĘPNE:
- Poprawa jakości obrazu
- Korekcja orientacji  
- Segmentacja strony
- Redukcja szumu

ANALIZA UKŁADU:
- Wykrywanie i wydobywanie tabel
- Identyfikacja pól formularzy
- Określanie kolejności czytania
- Rozumienie struktury

WYDOBYWANIE TREŚCI:
- OCR dla treści tekstowej
- Rozpoznawanie pisma odręcznego
- Wykrywanie checkboxów i podpisów
- Wydobywanie par klucz-wartość

LOGIKA BIZNESOWA:
- Walidacja i weryfikacja danych
- Integracja z systemami biznesowymi
- Automatyzacja przepływu pracy
- Obsługa wyjątków

Custom Document Models

from azure.ai.formrecognizer import DocumentAnalysisClient, DocumentModelAdministrationClient

def train_custom_document_model(training_data_url):
    # Inicjalizacja klientów
    admin_client = DocumentModelAdministrationClient(endpoint, credential)
    
    # Rozpoczęcie treningu
    poller = admin_client.begin_build_document_model(
        build_mode="template",  # lub "neural" dla złożonych układów
        blob_container_url=training_data_url,
        description="Niestandardowy model przetwarzania faktur"
    )
    
    model = poller.result()
    print(f"ID modelu: {model.model_id}")
    
    return model

def analyze_custom_document(document_url, model_id):
    client = DocumentAnalysisClient(endpoint, credential)
    
    poller = client.begin_analyze_document_from_url(
        model_id=model_id,
        document_url=document_url
    )
    
    result = poller.result()
    
    # Wydobywanie danych strukturalnych
    for document in result.documents:
        for field_name, field in document.fields.items():
            print(f"{field_name}: {field.value} (pewność: {field.confidence})")
    
    return result

📊 Advanced Document Intelligence

Przetwarzanie wielu dokumentów

SYSTEM PRZETWARZANIA WSADOWEGO DOKUMENTÓW:

KOMPONENTY:
1. POBIERANIE DOKUMENTÓW:
   - Monitorowanie przechowywania blob
   - Automatyczne wyzwalacze przetwarzania
   - Obsługa błędów i logika ponawiania

2. ORKIESTRACJA PRZETWARZANIA:
   - Azure Functions dla przetwarzania bezserwerowego
   - Logic Apps dla automatyzacji przepływu pracy
   - Service Bus dla kolejkowania komunikatów

3. PRZETWARZANIE RÓWNOLEGŁE:
   - Wiele typów dokumentów jednocześnie
   - Optymalizacja zasobów
   - Śledzenie postępu

4. AGREGACJA WYNIKÓW:
   - Skonsolidowane raportowanie
   - Metryki jakości danych
   - Integracja z business intelligence

IMPLEMENTACJA:
```python
import asyncio
from azure.storage.blob import BlobServiceClient

async def process_document_batch(container_name):
    blob_client = BlobServiceClient(connection_string)
    container_client = blob_client.get_container_client(container_name)
    
    # Lista wszystkich blobów w kontenerze
    blobs = container_client.list_blobs()
    
    # Przetwarzanie równoległe
    tasks = []
    for blob in blobs:
        if blob.name.endswith(('.pdf', '.jpg', '.png')):
            task = process_single_document(blob.url)
            tasks.append(task)
    
    # Oczekiwanie na zakończenie wszystkich procesów
    results = await asyncio.gather(*tasks)
    
    return aggregate_results(results)

async def process_single_document(document_url):
    # Analiza dokumentu za pomocą Form Recognizer
    result = await analyze_document_async(document_url)
    
    # Wydobywanie kluczowych informacji
    extracted_data = {
        'document_type': classify_document(result),
        'key_values': extract_key_values(result),
        'confidence_score': calculate_confidence(result),
        'processing_time': measure_processing_time()
    }
    
    return extracted_data

Sesja 12: Budowa systemu wyszukiwania i przetwarzania dokumentów (09.10.2025)

🏗️ Architektura systemu end-to-end

Kompleksowa platforma wyszukiwania i przetwarzania dokumentów

ARCHITEKTURA SYSTEMU:

[PRZESYŁANIE DOKUMENTÓW] → [POTOK PRZETWARZANIA] → [INDEKS WYSZUKIWANIA] → [INTERFEJS UŻYTKOWNIKA]
              ↓                        ↓                        ↓                    ↓
    [BLOB STORAGE] → [USŁUGI KOGNITYWNE] → [BAZA DANYCH WEKTOROWYCH] → [API WYSZUKIWANIA]
              ↓                        ↓                        ↓                    ↓
[KOPIA ZAPASOWA/ARCHIWUM] → [MONITOROWANIE/LOGI] → [ANALITYKA] → [PANEL ADMINISTRATORA]

KLUCZOWE FUNKCJE:
1. INTELIGENTNE PRZESYŁANIE:
   - Automatyczne wykrywanie typu treści
   - Wykrywanie duplikatów i deduplikacja
   - Wydobywanie metadanych podczas przesyłania
   - Skanowanie antywirusowe i walidacja bezpieczeństwa

2. ZAAWANSOWANE PRZETWARZANIE:
   - OCR dla zeskanowanych dokumentów
   - Wydobywanie i łączenie encji
   - Analiza semantyczna i kategoryzacja
   - Wykrywanie języka i tłumaczenie

3. INTELIGENTNE INDEKSOWANIE:
   - Generowanie embeddingów semantycznych
   - Tradycyjne indeksowanie słów kluczowych
   - Przygotowanie wyszukiwania aspektowego
   - Aktualizacje indeksu w czasie rzeczywistym

4. INTELIGENTNE WYSZUKIWANIE:
   - Zapytania w języku naturalnym
   - Wyszukiwanie podobieństwa wektorowego
   - Wyszukiwanie hybrydowe (słowa kluczowe + semantyczne)
   - Spersonalizowany ranking wyników

Warsztat implementacji

class IntelligentDocumentProcessor:
    def __init__(self, search_endpoint, form_recognizer_endpoint):
        self.search_client = SearchClient(search_endpoint, "documents", credential)
        self.form_recognizer = DocumentAnalysisClient(form_recognizer_endpoint, credential)
        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
    
    async def process_document(self, document_url, metadata=None):
        # Krok 1: Wydobywanie treści za pomocą Form Recognizer
        analysis_result = await self.analyze_document_structure(document_url)
        
        # Krok 2: Generowanie embeddingów semantycznych
        content_text = self.extract_text_content(analysis_result)
        embeddings = self.embedding_model.encode(content_text)
        
        # Krok 3: Tworzenie dokumentu wyszukiwania
        search_document = {
            "id": generate_document_id(document_url),
            "title": self.extract_title(analysis_result),
            "content": content_text,
            "contentVector": embeddings.tolist(),
            "documentType": self.classify_document_type(analysis_result),
            "extractedEntities": self.extract_entities(content_text),
            "confidence": self.calculate_overall_confidence(analysis_result),
            "uploadDate": datetime.utcnow().isoformat(),
            "metadata": metadata or {}
        }
        
        # Krok 4: Indeksowanie dla wyszukiwania
        result = await self.search_client.upload_documents([search_document])
        
        return {
            "documentId": search_document["id"],
            "processingStatus": "completed",
            "extractedData": search_document,
            "searchResult": result
        }
    
    async def intelligent_search(self, query, filters=None, top=10):
        # Generowanie embedding zapytania
        query_vector = self.embedding_model.encode(query).tolist()
        
        # Wyszukiwanie hybrydowe: semantyczne + słowa kluczowe
        search_results = await self.search_client.search(
            search_text=query,
            vector_queries=[VectorizedQuery(
                vector=query_vector,
                k_nearest_neighbors=top,
                fields="contentVector"
            )],
            filter=filters,
            top=top,
            include_total_count=True
        )
        
        return search_results

🎯 Aspekty wdrażania produkcyjnego

Skalowalność i wydajność

WYMAGANIA PRODUKCYJNE:

CELE WYDAJNOŚCIOWE:
- Przetwarzanie dokumentów: <30 sekund dla PDF 10MB
- Czas odpowiedzi wyszukiwania: <200ms dla prostych zapytań
- Jednoczesni użytkownicy: 100+ jednocześnie
- Rozmiar indeksu: 1M+ dokumentów

STRATEGIA SKALOWANIA:
- Auto-skalowanie jednostek wyszukiwania w oparciu o obciążenie
- Równoległe przetwarzanie dokumentów
- CDN dla dostarczania treści statycznych
- Strategie buforowania dla częstych zapytań

MONITOROWANIE I ANALITYKA:
- Application Insights dla śledzenia wydajności
- Niestandardowe metryki dla biznesowych KPI
- Reguły alertów dla zdrowia systemu
- Analityka użytkowania dla optymalizacji

ZAGADNIENIA BEZPIECZEŃSTWA:
- Kontrola dostępu oparta na rolach (RBAC)
- Przycinanie bezpieczeństwa na poziomie dokumentu
- Szyfrowanie w spoczynku i podczas przesyłania
- Logowanie audytu dla zgodności

🏆 Ocena modułu

Praktyczne rezultaty

  1. Działający asystent głosowy z podstawowym przetwarzaniem poleceń
  2. Niestandardowy model klasyfikacji obrazów dla konkretnego przypadku użycia
  3. Potok przetwarzania dokumentów z OCR i wydobywaniem encji
  4. Zintegrowany system wyszukiwania łączący wyszukiwanie semantyczne + słowa kluczowe

Walidacja umiejętności technicznych

  • Konfiguracja i użytkowanie Azure Cognitive Services
  • Programowanie w Pythonie dla aplikacji AI
  • Integracja API i obsługa błędów
  • Techniki optymalizacji wydajności

Przygotowanie do certyfikacji

  • Praktyczne doświadczenie z usługami Azure AI istotnymi dla egzaminu AI-102
  • Zrozumienie architektur AI multimodalnych
  • Praktyczna wiedza na temat wdrażania i monitorowania

🤖 Materiał przygotowany zgodnie z harmonogramem Azure AI Engineer Associate - praktyczne przygotowanie do certyfikacji Microsoft AI-102.

💡 Wskazówka

Każda sesja to 2 godziny intensywnej nauki z praktycznymi ćwiczeniami. Materiały można przeglądać w dowolnym tempie.

📈 Postęp

Śledź swój postęp w nauce AI i przygotowaniu do certyfikacji Azure AI-102. Każdy moduł buduje na poprzednim.