Návod: Sestavení komplexního řešení agentního vyhledávání pomocí Azure AI Vyhledávač

Zjistěte, jak vytvořit inteligentní řešení s podporou MCP, které integruje Azure AI Vyhledávač se službou Foundry Agent Service pro agentické načítání. Tuto architekturu můžete použít pro konverzační aplikace, které vyžadují složité důvody pro velké znalostní domény, jako je zákaznická podpora nebo technické řešení potíží.

V tomto kurzu se používají plochy rozhraní REST API ve verzi Preview na dvou místech. Znalostní báze používá output_mode a retrieval_reasoning_effort (Preview) k explicitní specifikaci extrahujícího výstupu a minimálního odůvodnění, i když je obecně dostupné ekvivalentní chování. Připojení k projektu používá RemoteTool (verze Preview) a spravovanou identitu projektu pro ověřování vůči službě Azure AI Vyhledávač.

V tomto kurzu:

Požadavky

• Služba Azure AI Vyhledávač v jakémkoli regionu , která poskytuje agentické vyhledávání.

• Projekt Microsoft Foundry a zdroj. Při vytváření projektu se zdroj vytvoří automaticky.

• Model vkládání textu nasazený do projektu pro vektorizaci času dotazu. Toto řešení používá text-embedding-3-large.

• LLM integrovaný do vašeho projektu pro agenta Toto řešení používá gpt-5-mini.

  Modely rodiny GPT-4 jsou zastaralé. Data vyřazení a aktuální stav v Microsoft Foundry najdete v části Plán vyřazení modelu – Microsoft Foundry.

• Oprávnění k přístupu a správě prostředků Azure AI Vyhledávač a Microsoft Foundry Další informace najdete v tématu Konfigurace přístupu.

• Python 3.8 nebo novější

• Visual Studio Code s rozšířeními Python a Jupyter.

• Azure CLI pro ověřování bez klíčů pomocí Microsoft Entra ID.

Vysvětlení řešení

Toto řešení kombinuje Azure AI Vyhledávač a Microsoft Foundry k vytvoření kompletního kanálu načítání:

• Azure AI Vyhledávač hostuje znalostní bázi, která zpracovává plánování dotazů, spouštění dotazů a syntézu výsledků. Vytvoříte vyhledávací index pro ukládání obsahu, zdroje znalostí, který odkazuje na index, a znalostní bázi, která provádí hybridní načítání ze zdroje znalostí.

• Microsoft Foundry hostuje nasazení modelů OpenAI, připojení projektu a agenta Azure. Vytvoříte připojení projektu, které odkazuje na koncový bod MCP znalostní báze, a pak vytvoříte agenta, který používá nástroj MCP pro přístup ke znalostní bázi.

Uživatel zahájí zpracování dotazů interakcí s klientskou aplikací, jako je chatovací robot, který volá agenta. Agent pomocí nástroje MCP orchestruje požadavky na znalostní bázi a syntetizuje odpovědi. Když chatbot zavolá agenta, nástroj MCP zavolá znalostní bázi v Azure AI Vyhledávač a odešle odpověď agentu a chatbotu.

Konfigurace přístupu

Než začnete, ujistěte se, že máte oprávnění pro přístup k obsahu a operacím. Pro ověřování a přístup na základě role pro autorizaci doporučujeme Microsoft Entra ID. Abyste mohli přiřadit role, musíte být vlastníkem nebo správcem uživatelských přístupů . Pokud role nejsou proveditelné, použijte místo toho ověřování založené na klíči .

Konfigurace přístupu pro toto řešení:

1. Přihlaste se k portálu Azure.

2. Povolte spravovanou identitu přiřazenou systémem pro vyhledávací službu i váš projekt. Můžete to udělat na stránce Identita každého prostředku.

3. Ve vyhledávací službě povolte přístup na základě role a přiřaďte následující role.

   Roli	Přiřazený uživatel	Účel
   Přispěvatel vyhledávací služby	Váš uživatelský účet	Vytváření objektů
   Přispěvatel dat indexu vyhledávání	Váš uživatelský účet	Načtení dat
   Čtečka dat indexu vyhledávání	Váš uživatelský účet a spravovaná identita projektu	Čtení indexovaného obsahu

4. U nadřazeného zdroje projektu přiřaďte následující role.

   Roli	Přiřazený uživatel	Účel
   Uživatel Foundry	Váš uživatelský účet	Přistupujte k nasazováním modelů a vytvářejte agenty
   Správce projektu Foundry	Váš uživatelský účet	Vytvoření připojení k projektu a použití nástroje MCP v agentech
   Uživatel služeb Cognitive Services	Spravovaná identita vyhledávací služby	Přístup ke znalostní bázi

Nastavení prostředí

1. Vytvořte složku s názvem tutorial-agentic-retrieval v místním systému.

2. Otevřete složku v Visual Studio Code.

3. Vyberte View>Command Palette a pak vyberte Python: Create Environment. Podle pokynů vytvořte virtuální prostředí.

4. Vyberte Terminál>Nový terminál.

5. Nainstalujte požadované balíčky.

   pip install azure-ai-projects==2.0.0b1 azure-mgmt-cognitiveservices azure-identity ipykernel python-dotenv azure-search-documents==11.7.0b2 requests openai
   

6. Vytvořte soubor s názvem .env ve tutorial-agentic-retrieval složce.

7. Přidejte do .env souboru následující proměnné a nahraďte zástupné hodnoty vlastními hodnotami.

   AZURE_SEARCH_ENDPOINT = https://{your-service-name}.search.windows.net
   PROJECT_ENDPOINT = https://{your-resource-name}.services.ai.azure.com/api/projects/{your-project-name}
   PROJECT_RESOURCE_ID = /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/Microsoft.CognitiveServices/accounts/{account-name}/projects/{project-name}
   AZURE_OPENAI_ENDPOINT = https://{your-resource-name}.openai.azure.com
   AZURE_OPENAI_EMBEDDING_DEPLOYMENT = text-embedding-3-large
    AGENT_MODEL = gpt-5-mini
   

   Koncové body a ID prostředku najdete na portálu Azure:

   • AZURE_SEARCH_ENDPOINT je na stránce Přehled vaší vyhledávací služby.

   • PROJECT_ENDPOINT je na stránce Koncové body vašeho projektu.

   • PROJECT_RESOURCE_ID je na stránce Vlastnosti projektu.

   • AZURE_OPENAI_ENDPOINT je na stránce Koncové body nadřazeného zdroje vašeho projektu.

8. Pro ověřování bez klíčů pomocí Microsoft Entra ID se přihlaste ke svému účtu Azure. Pokud máte více předplatných, vyberte předplatné, které obsahuje vaše prostředky Azure AI Vyhledávač a Microsoft Foundry.

   az login
   

9. Vytvořte soubor s názvem tutorial.ipynb ve tutorial-agentic-retrieval složce. Do tohoto souboru přidáte buňky kódu v další části.

Sestavení řešení

V této části vytvoříte komponenty agentního systému pro načítání dat. Přidejte každý fragment kódu do samostatné buňky kódu v poznámkovém tutorial.ipynb bloku a sekvenčně spouštějte buňky.

Kroky v této části zahrnují:

1. Načíst připojení
2. Vytvoření indexu vyhledávání
3. Nahrání dokumentů do indexu
4. Vytvoření zdroje znalostí
5. Vytvoření znalostní báze
6. Nastavení klienta projektu
7. Vytvořte připojení projektu
8. Vytvoření agenta pomocí nástroje MCP
9. Chat s agentem
10. Vyčištění prostředků

Načíst připojení

Následující kód načte proměnné prostředí ze souboru .env a vytvoří připojení k Azure AI Vyhledávač a Microsoft Foundry.

import os

from azure.identity import DefaultAzureCredential
from azure.mgmt.core.tools import parse_resource_id
from dotenv import load_dotenv

load_dotenv(override=True) # Take environment variables from .env

project_endpoint = os.environ["PROJECT_ENDPOINT"]
project_resource_id = os.environ["PROJECT_RESOURCE_ID"]
project_connection_name = os.getenv("PROJECT_CONNECTION_NAME", "earthknowledgeconnection")
agent_model = os.getenv("AGENT_MODEL", "gpt-5-mini")
agent_name = os.getenv("AGENT_NAME", "earth-knowledge-agent")
endpoint = os.environ["AZURE_SEARCH_ENDPOINT"]
credential = DefaultAzureCredential()
knowledge_source_name = os.getenv("AZURE_SEARCH_KNOWLEDGE_SOURCE_NAME", "earth-knowledge-source")
index_name = os.getenv("AZURE_SEARCH_INDEX", "earth-at-night")
azure_openai_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]
azure_openai_embedding_deployment = os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT", "text-embedding-3-large")
azure_openai_embedding_model = os.getenv("AZURE_OPENAI_EMBEDDING_MODEL", "text-embedding-3-large")
base_name = os.getenv("AZURE_SEARCH_AGENT_NAME", "earth-knowledge-base")

# Parse the resource ID to extract subscription and other components
parsed_resource_id = parse_resource_id(project_resource_id)
subscription_id = parsed_resource_id['subscription']
resource_group = parsed_resource_id['resource_group']
account_name = parsed_resource_id['name']
project_name = parsed_resource_id['child_name_1']

Vytvoření indexu vyhledávání

V Azure AI Vyhledávač je index strukturovanou kolekcí dat. Následující kód vytvoří index pro ukládání prohledávatelného obsahu znalostní báze.

Schéma indexu obsahuje pole pro identifikaci dokumentu a obsah stránky, vkládání a čísla. Schéma také obsahuje konfigurace pro sémantické řazení a vektorové vyhledávání, které používá vaše text-embedding-3-large nasazení k vektorizaci textu a porovnávání dokumentů na základě sémantické podobnosti.

Další informace o tomto postupu najdete v tématu Vytvoření indexu pro agentní načítání v Azure AI Vyhledávač.

from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
    AzureOpenAIVectorizer, AzureOpenAIVectorizerParameters,
    HnswAlgorithmConfiguration, SearchField, SearchIndex,
    SemanticConfiguration, SemanticField, SemanticPrioritizedFields,
    SemanticSearch, VectorSearch, VectorSearchProfile
)

index = SearchIndex(
    name=index_name,
    fields=[
        SearchField(name="id", type="Edm.String", key=True, filterable=True, sortable=True, facetable=True),
        SearchField(name="page_chunk", type="Edm.String", filterable=False, sortable=False, facetable=False),
        SearchField(name="page_embedding_text_3_large", type="Collection(Edm.Single)", stored=False, vector_search_dimensions=3072, vector_search_profile_name="hnsw_text_3_large"),
        SearchField(name="page_number", type="Edm.Int32", filterable=True, sortable=True, facetable=True)
    ],
    vector_search=VectorSearch(
        profiles=[VectorSearchProfile(name="hnsw_text_3_large", algorithm_configuration_name="alg", vectorizer_name="azure_openai_text_3_large")],
        algorithms=[HnswAlgorithmConfiguration(name="alg")],
        vectorizers=[
            AzureOpenAIVectorizer(
                vectorizer_name="azure_openai_text_3_large",
                parameters=AzureOpenAIVectorizerParameters(
                    resource_url=azure_openai_endpoint,
                    deployment_name=azure_openai_embedding_deployment,
                    model_name=azure_openai_embedding_model
                )
            )
        ]
    ),
    semantic_search=SemanticSearch(
        default_configuration_name="semantic_config",
        configurations=[
            SemanticConfiguration(
                name="semantic_config",
                prioritized_fields=SemanticPrioritizedFields(
                    content_fields=[
                        SemanticField(field_name="page_chunk")
                    ]
                )
            )
        ]
    )
)

index_client = SearchIndexClient(endpoint=endpoint, credential=credential)
index_client.create_or_update_index(index)
print(f"Index '{index_name}' created or updated successfully")

Nahrání dokumentů do indexu

Index je v současné době prázdný. Následující kód naplní index dokumenty JSON z e-knihy NASA's Earth at Night. Podle Azure AI Vyhledávač odpovídá každý dokument polím a datovým typům definovaným ve schématu indexu.

Další informace o tomto kroku naleznete v tématu Vložení dat do indexu.

import requests
from azure.search.documents import SearchIndexingBufferedSender

url = "https://raw.githubusercontent.com/Azure-Samples/azure-search-sample-data/refs/heads/main/nasa-e-book/earth-at-night-json/documents.json"
documents = requests.get(url).json()

with SearchIndexingBufferedSender(endpoint=endpoint, index_name=index_name, credential=credential) as client:
    client.upload_documents(documents=documents)

print(f"Documents uploaded to index '{index_name}'")

Vytvoření zdroje znalostí

Zdroj znalostí je opakovaně použitelný odkaz na zdrojová data. Následující kód vytvoří zdroj znalostí, který cílí na index, který jste vytvořili dříve.

source_data_fields určuje, která pole indexu jsou zahrnuta do odkazů na citaci. Tento příklad obsahuje pouze pole čitelná pro člověka, aby nedocházelo k zdlouhavým, neinterpretovatelným vkládáním do odpovědí.

Další informace o tomto kroku najdete v tématu Vytvoření zdroje znalostí indexu vyhledávání.

from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
    SearchIndexFieldReference, SearchIndexKnowledgeSource,
    SearchIndexKnowledgeSourceParameters
)

ks = SearchIndexKnowledgeSource(
    name=knowledge_source_name,
    description="Knowledge source for Earth at night data",
    search_index_parameters=SearchIndexKnowledgeSourceParameters(
        search_index_name=index_name,
        semantic_configuration_name="semantic_config",
        source_data_fields=[
            SearchIndexFieldReference(name="id"),
            SearchIndexFieldReference(name="page_chunk"),
            SearchIndexFieldReference(name="page_number")
        ]
    ),
)

index_client = SearchIndexClient(endpoint=endpoint, credential=credential)
index_client.create_or_update_knowledge_source(knowledge_source=ks)
print(f"Knowledge source '{knowledge_source_name}' created or updated successfully.")

Vytvoření znalostní báze

Následující kód vytvoří znalostní bázi, která orchestruje agentní načítání z vašeho zdroje znalostí. Kód také ukládá koncový bod MCP znalostní báze, který bude váš agent používat pro přístup ke znalostní bázi.

Pro integraci se službou Foundry Agent service je znalostní báze nakonfigurovaná s následujícími parametry:

• output_mode (verze Preview) je nastavena na extraktivní data, která agentovi poskytují doslovný, nezpracovaný obsah pro ukotvení a uvažování. Alternativní režim, syntéza odpovědí, vrací předem generované odpovědi, které agenta omezují ve schopnosti pracovat se zdrojovým obsahem.

• retrieval_reasoning_effort (preview) je nastaveno na minimální režim zpracování, který obchází plánování dotazů založené na LLM, aby se snížily náklady a latence. Z jiných důvodů znalostní báze používá LLM k přeformátování uživatelských dotazů před načtením.

Další informace o tomto kroku najdete v tématu Vytvoření znalostní báze v Azure AI Vyhledávač.

from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import KnowledgeBase, KnowledgeSourceReference
from azure.search.documents.knowledgebases.models import KnowledgeRetrievalMinimalReasoningEffort

knowledge_base = KnowledgeBase(
    name=base_name,
    knowledge_sources=[
        KnowledgeSourceReference(
            name=knowledge_source_name
        )
    ],
    output_mode="extractiveData",
    retrieval_reasoning_effort=KnowledgeRetrievalMinimalReasoningEffort()
)


index_client = SearchIndexClient(endpoint=endpoint, credential=credential)
index_client.create_or_update_knowledge_base(knowledge_base=knowledge_base)
print(f"Knowledge base '{base_name}' created or updated successfully")

mcp_endpoint = f"{endpoint.rstrip('/')}/knowledgebases/{base_name}/mcp?api-version=2026-08-01-preview"

Nastavení klienta projektu

Pomocí AIProjectClient vytvořte připojení klienta k projektu Microsoft Foundry. Váš projekt možná ještě neobsahuje žádné agenty, ale pokud jste už tento kurz dokončili, agent je tady uvedený.

from azure.ai.projects import AIProjectClient

project_client = AIProjectClient(endpoint=project_endpoint, credential=credential)

list(project_client.agents.list())

Vytvořte připojení projektu

Následující kód vytvoří v Microsoft Foundry RemoteTool připojení k projektu (ve verzi Preview), které odkazuje na koncový bod MCP vaší znalostní báze. Toto připojení používá identitu spravovanou projektem k ověření v Azure AI Vyhledávač.

import requests
from azure.identity import get_bearer_token_provider

bearer_token_provider = get_bearer_token_provider(credential, "https://management.azure.com/.default")
headers = {
    "Authorization": f"Bearer {bearer_token_provider()}",
}

response = requests.put(
    f"https://management.azure.com{project_resource_id}/connections/{project_connection_name}?api-version=2025-10-01-preview",
    headers=headers,
    json={
        "name": project_connection_name,
        "type": "Microsoft.MachineLearningServices/workspaces/connections",
        "properties": {
            "authType": "ProjectManagedIdentity",
            "category": "RemoteTool",
            "target": mcp_endpoint,
            "isSharedToAll": True,
            "audience": "https://search.azure.com/",
            "metadata": { "ApiType": "Azure" }
        }
    }
)

response.raise_for_status()
print(f"Connection '{project_connection_name}' created or updated successfully.")

Vytvoření agenta pomocí nástroje MCP

Následující kód vytvoří agenta nakonfigurovaného pomocí nástroje MCP. Když agent obdrží uživatelský dotaz, může pomocí nástroje MCP volat znalostní bázi k načtení relevantního obsahu pro podložení odpovědi.

Definice agenta obsahuje pokyny, které určují jeho chování a připojení projektu, které jste vytvořili dříve. Na základě našich experimentů jsou tyto pokyny účinné při maximalizaci přesnosti vyvolání znalostní báze a zajištění správného formátování citace.

Další informace o tomto kroku najdete v tématu Rychlý start: Vytvoření nového agenta.

from azure.ai.projects.models import PromptAgentDefinition, MCPTool

instructions = """
You are a helpful assistant that must use the knowledge base to answer all the questions from user. You must never answer from your own knowledge under any circumstances.
Every answer must always provide annotations for using the MCP knowledge base tool and render them as: `【message_idx:search_idx†source_name】`
If you cannot find the answer in the provided knowledge base you must respond with "I don't know".
"""

mcp_kb_tool = MCPTool(
    server_label="knowledge-base",
    server_url=mcp_endpoint,
    require_approval="never",
    allowed_tools=["knowledge_base_retrieve"],
    project_connection_id=project_connection_name
)

agent = project_client.agents.create_version(
    agent_name=agent_name,
    definition=PromptAgentDefinition(
        model=agent_model,
        instructions=instructions,
        tools=[mcp_kb_tool]
    )
)

print(f"AI agent '{agent_name}' created or updated successfully")

(Volitelné) Vynutit oprávnění pomocí hlaviček jednotlivých požadavků

Pokud některý z vašich zdrojů znalostí obsahuje obsah chráněný oprávněním, modul načítání může filtrovat výsledky tak, aby každý uživatel viděl jenom dokumenty, ke kterým má oprávnění přistupovat. Pokud chcete toto filtrování povolit, předáte token identity přihlášeného uživatele v x-ms-query-source-authorization hlavičce připojení nástroje MCP. Bez tokenu vrátí zdroje s povolenými oprávněními nefiltrované výsledky. Další informace najdete v tématu Vynucení oprávnění v době dotazu (Preview).

Chcete-li měnit hlavičky MCP pro každý požadavek, například předávat při každém volání token jiného uživatele, deklarujte v definici agenta strukturovaný vstup a odkažte na něj jako na {{placeholder}} v headers nástroje. Volající poskytuje hodnotu pro každé vyvolání. Tento přístup funguje pro nástroje MCP vázané na připojení k projektu.

Pro autorizaci pro jednotlivé uživatele na serveru MCP můžete použít také předávání identity OAuth.

Následující kód aktualizuje agenta z předchozího kroku, aby nástroj MCP přečetl autorizační hlavičku ze strukturovaného vstupu.

from azure.ai.projects.models import StructuredInputDefinition

# Reference the token as a placeholder in the header
mcp_kb_tool = MCPTool(
    server_label="knowledge-base",
    server_url=mcp_endpoint,
    require_approval="never",
    allowed_tools=["knowledge_base_retrieve"],
    project_connection_id=project_connection_name,
    headers={
        "x-ms-query-source-authorization": "{{search_auth_token}}"
    }
)

# Declare the structured input so the caller can supply the token per request
agent = project_client.agents.create_version(
    agent_name=agent_name,
    definition=PromptAgentDefinition(
        model=agent_model,
        instructions=instructions,
        tools=[mcp_kb_tool],
        structured_inputs={
            "search_auth_token": StructuredInputDefinition(
                description="Per-user Azure AI Search bearer token",
                required=True,
                schema={"type": "string"},
            )
        }
    )
)

print(f"AI agent '{agent_name}' created or updated successfully")

Při vyvolání agenta zadejte token Azure AI Vyhledávač v structured_inputs. Tento příklad vyřeší token z aktuálního credential. V případě aplikace pro více uživatelů předejte token každého přihlášeného uživatele. Použijte například token získaný prostřednictvím toku on-behalf-of, aby vyhledávací modul mohl filtrovat výsledky pro daného uživatele.

# Resolve an Azure AI Search token from the current credential (use a per-user token in production)
from azure.identity import get_bearer_token_provider

search_token = get_bearer_token_provider(credential, "https://search.azure.com/.default")()

openai_client = project_client.get_openai_client()
conversation = openai_client.conversations.create()

response = openai_client.responses.create(
    conversation=conversation.id,
    tool_choice="required",
    input="{user_query}",
    extra_body={
        "agent_reference": {"name": agent.name, "type": "agent_reference"},
        "structured_inputs": {"search_auth_token": search_token},
    },
)

print(f"Response: {response.output_text}")

Chat s agentem

Vaše klientská aplikace používá k interakci s agentem rozhraní API pro konverzace a odpovědi z Azure OpenAI.

Následující kód vytvoří konverzaci a předá agenta zprávy uživatelů, které se podobají typickému chatu. Agent určí, kdy dotazovat znalostní bázi pomocí nástroje MCP a vrátí odpověď v přirozeném jazyce včetně odkazů. Nastavení tool_choice="required" zajišťuje, že agent při zpracování dotazů vždy používá nástroj znalostní báze.

# Get the OpenAI client for responses and conversations
openai_client = project_client.get_openai_client()

conversation = openai_client.conversations.create()

# Send initial request that will trigger the MCP tool
response = openai_client.responses.create(
    conversation=conversation.id,
    tool_choice="required",
    input="""
        Why do suburban belts display larger December brightening than urban cores even though absolute light levels are higher downtown?
        Why is the Phoenix nighttime street grid is so sharply visible from space, whereas large stretches of the interstate between midwestern cities remain comparatively dim?
    """,
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)

print(f"Response: {response.output_text}")

Odpověď by měla být podobná následujícímu příkladu.

Response: Here are evidence-based explanations to your questions:

---

**1. Why do suburban belts display larger December brightening than urban cores, even though absolute light levels are higher downtown?**

- Suburban belts show a *larger percentage increase* in night brightness during December compared to urban cores, largely because suburban residential areas feature more single-family homes and larger yards, which are typically decorated with holiday lights. These areas start from a lower baseline (less bright overall at night compared to dense urban centers), so the relative change (brightening) is much more noticeable.

- In contrast, the downtown core is already very bright at night due to dense commercial lighting and streetlights. While it also sees a December increase (often 20–30% brighter), the *absolute* change is less striking because it begins at a much higher base of illumination.

- This pattern is observed across U.S. cities, with the phenomenon driven by widespread cultural practices and the suburban landscape’s suitability for holiday lighting displays. The effect is visible in satellite data and was quantified at 20–50% brighter in December, especially in suburbs and city outskirts.

---

**2. Why is the Phoenix nighttime street grid so sharply visible from space, whereas large stretches of the interstate between midwestern cities remain comparatively dim?**

- Phoenix’s sharply visible nighttime street grid from space is a result of its urban layout: the city (like many western U.S. cities) was developed using a regular grid system, with extensive and uniform street lighting and strong urban sprawl. The grid pattern, and the dense network of intersecting surface streets, is brightly illuminated, particularly at intersections, commercial areas, and major thoroughfares.

- The interstate highways between midwestern cities, though significant in length and crucial to national infrastructure, traverse sparsely populated rural areas. These stretches typically have very little artificial lighting (due to low traffic volumes at night and cost considerations), making them much less visible in nighttime satellite imagery. Only nodes (cities and towns) along the route show as bright "pearls" in the darkness, while the "strings" (highways) connecting them remain faint or invisible.

- In summary:
  - Urban areas like Phoenix stand out with strong, connected patterns of light due to dense development and extensive lighting.
  - Rural interstates are sparsely lit, and only their endpoints—cities and large towns—generate notable light visible from space.

---

**References**:
- [Holiday Lights increase most dramatically in suburbs, not downtowns: earth_at_night_508_page_176_verbalized, page 160](4:5)
- [Lighting paths and urban grids are visible from space, while rural highways remain dim: earth_at_night_508_page_124_verbalized, page 108](4:3)
- [Phoenix’s grid and surrounding urban structure: earth_at_night_508_page_104_verbalized, page 88](4:1)

Kontrola odpovědi

Podkladová odpověď od agenta obsahuje metadata o dotazech odeslaných do znalostní báze a nalezených citací. Tato metadata můžete zkontrolovat, abyste pochopili, jak agent zpracoval uživatelský vstup.

response.to_dict()

Vyčištění prostředků

Když pracujete ve vlastním předplatném, je vhodné dokončit projekt odebráním prostředků, které už nepotřebujete. Prostředky, které zůstávají spuštěné, vás mohou stát peníze.

Na portálu Azure vyberte Všechny prostředky nebo Zdrojové skupiny v levém podokně a vyhledejte a spravujte prostředky. Prostředky můžete odstranit jednotlivě nebo odstranit skupinu prostředků a odebrat tak všechny prostředky najednou.

Můžete také spustit následující kód, který odstraní jednotlivé objekty:

# Delete the agent
project_client.agents.delete_version(agent.name, agent.version)
print(f"AI agent '{agent.name}' version '{agent.version}' deleted successfully")

# Delete the knowledge base
index_client.delete_knowledge_base(base_name)
print(f"Knowledge base '{base_name}' deleted successfully")

# Delete the knowledge source
index_client.delete_knowledge_source(knowledge_source=knowledge_source_name)
print(f"Knowledge source '{knowledge_source_name}' deleted successfully.")

# Delete the search index
index_client.delete_index(index_name)
print(f"Index '{index_name}' deleted successfully")

Zlepšení kvality dat

Ve výchozím nastavení se výsledky vyhledávání ze znalostních bází sloučí do jednoho velkého řetězce, který můžete předat agentům jako podklad. Azure AI Vyhledávač poskytuje následující funkce indexování a ladění relevance, které vám pomůžou generovat vysoce kvalitní výsledky. Tyto funkce můžete implementovat v indexu vyhledávání a vylepšení relevance vyhledávání jsou zřejmé v kvalitě výsledků vyhledávání.

• Profily bodování poskytují předdefinovaná kritéria pro zvýšení. Index musí určovat výchozí bodovací profil, který modul pro načítání používá, když dotazy obsahují pole přidružená k tomuto profilu.

• Je vyžadována sémantická konfigurace , ale určíte, která pole mají prioritu a která se použijí pro řazení.

• Pro obsah ve formátu prostého textu můžete pomocí analyzátorů řídit tokenizaci během indexování.

• Pro multimodální nebo obrázkový obsah můžete použít verbalizaci obrázků pro popisy generované LLM vašich obrázků nebo klasické OCR a analýzu obrázků pomocí sad dovedností během indexování.

Řízení počtu poddotazů

Počet poddotazů můžete řídit nastavením úsilí při načítání (Preview) ve znalostní bázi. Úsilí o odůvodnění určuje úroveň zpracování LLM pro plánování dotazů, od minimálního (bez zpracování LLM) až po střední (hlubší vyhledávání a následné iterace).

V případě ne minimálního úsilí o odůvodnění určuje LLM počet poddotazů na základě následujících faktorů:

• Dotaz uživatele
• Historie chatu
• Sémantická omezení vstupu rankeru

Řízení kontextu odeslaného agentovi

Rozhraní API odpovědí určuje, co se posílá agentovi a do znalostní báze. Pokud chcete optimalizovat výkon a relevanci, upravte pokyny agenta, abyste před odesláním do nástroje MCP shrnuli nebo vyfiltrovali historii chatu.

Řízení nákladů a omezení provozu

Pokud chcete získat přehled o plánu dotazů, podívejte se na výstupní tokeny v poli aktivit odpovědí znalostní báze.

Zvýšení výkonu

Pokud chcete optimalizovat výkon a snížit latenci, zvažte následující strategie:

• Shrnout vlákna zpráv

• Používejte gpt-5-mini nebo menší model, který funguje rychleji.

• Nastavte maxOutputSize na akci načtení, abyste upravili velikost odpovědi, nebo maxRuntimeInSeconds pro časově omezené zpracování.

• Před indexováním rozdělte velké dokumenty na menší části. Dokumenty, které překračují rozpočet výstupu, se dají bezobslužně vynechat ze zeměných výsledků.

Související obsah

• Agentic vyhledávání v Azure AI Vyhledávač
• Agentic RAG: Sestavte vyhledávací modul pro analytickou práci pomocí Azure AI Vyhledávač (YouTube video)
• Azure demonstrace OpenAI s pojmovým vyhledáváním