Självstudie: Skapa en lösning för agentisk hämtning från slutpunkt till slutpunkt med hjälp av Azure AI-sökning

Observera

Azure AI-sökning är tillgängligt via Azure-portalen, REST-API:er och Azure-SDK:er. Den ligger också till grund för Foundry IQ, det hanterade kunskapsskiktet som omvandlar företagsinnehåll till återanvändbara, behörighetsmedvetna kunskapsbaser för agenter i Microsoft Foundry-portalen.

Observera

Vissa funktioner för agentisk hämtning är allmänt tillgängliga i REST-API:et 2026-04-01. Den här artikeln använder dock förhandsversionen av 2026-05-01 för att demonstrera den fullständiga funktionsuppsättningen, inklusive funktioner som finns kvar i förhandsversionen. Förhandsversionsfunktioner tillhandahålls utan serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Mer information finns i Supplemental Terms of Use for Microsoft Azure Previews.

Viktigt

De här funktionerna är en del av REST API:et för förhandsversionen av 2026-05-01. Förhandsversionen av 2026-05-01 är licensierad till dig som en del av din Azure-prenumeration och omfattas av de villkor som gäller för "förhandsversioner" i Microsoft produktvillkor, Microsoft Products and Services Data Protection Addendum ("DPA" och Supplemental Terms of Use for for Microsoft Azure förhandsversioner.

Förhandsversionen av 2026-05-01 stöder anslutningar till andra Microsoft-tjänster- och tredjepartstjänster. Användningen av dessa tjänster omfattas av deras respektive villkor och kan resultera i databearbetning eller lagring utanför Azure efterlevnadsgräns, samt data som flödar till Azure efterlevnadsgräns.

Det är ditt ansvar att hantera om dina data kommer att flöda utanför organisationens efterlevnad och geografiska gränser och eventuella relaterade konsekvenser, och att lämpliga behörigheter, gränser och godkännanden etableras.

MCP-implementeringar är mottagliga för risker, till exempel attacker, sammanhängande fel och förlust av mänsklig tillsyn. Du kan minska dessa risker genom att granska MCP-servrar för säkerhet och tillförlitlighet, enligt bästa praxis för Microsoft och industry och implementera godkännandemekanismer och övervakning av sammanhängande beteenden.

Du ansvarar för att noggrant granska och testa program som du skapar i samband med dina specifika användningsfall och fatta alla lämpliga beslut och anpassningar. Detta omfattar implementering av dina egna ansvarsfulla AI-åtgärder, till exempel metaprompter, innehållsfilter eller andra säkerhetssystem, och att se till att dina program uppfyller lämpliga kvalitets-, tillförlitlighets-, säkerhets- och tillförlitlighetsstandarder. Mer information finns i Azure AI-sökning Transparency Note.

Lär dig hur du skapar en intelligent, MCP-aktiverad lösning som integrerar Azure AI-sökning med Foundry Agent Service för agentisk hämtning. Du kan använda den här arkitekturen för konversationsprogram som kräver komplexa resonemang över stora kunskapsdomäner, till exempel kundsupport eller teknisk felsökning.

I den här handledningen:

  • Konfigurera rollbaserad åtkomst för Azure AI-sökning och Microsoft Foundry
  • Skapa ett sökindex, en kunskapskälla och en kunskapsbas i Azure AI-sökning
  • Skapa en projektanslutning för MCP-kommunikation mellan Azure AI-sökning och Microsoft Foundry
  • Skapa en agent i Microsoft Foundry som använder MCP-verktyget för hämtning
  • Testa lösningen genom att chatta med agenten
  • Läs tips för att optimera lösningen

Diagram över pipelinen för agentbaserad hämtning från början till slut som visar integration av Azure AI-sökning med Foundry Agent Service via MCP.

Tips

Förutsättningar

Viktigt

Om du inaktiverar åtkomsten till det offentliga nätverket för söktjänsten och använder den som ett agentverktyg med en nätverksisolerad Microsoft Foundry-resurs måste du använda portalen Microsoft Foundry (ny), SDK eller CLI för att skapa agenter. Portalen Microsoft Foundry (klassisk) stöder inte det här scenariot. Mer information finns i Agentverktyg med nätverksisolering.

Förstå lösningen

Den här lösningen kombinerar Azure AI-sökning och Microsoft Foundry för att skapa en pipeline för hämtning från slutpunkt till slutpunkt:

  • Azure AI-sökning är värd för din kunskapsbas, som hanterar frågeplanering, frågekörning och resultatsyntes. Du skapar ett sökindex för att lagra innehåll, en kunskapskälla som refererar till indexet och en kunskapsbas som utför hybridhämtning från kunskapskällan.

  • Microsoft Foundry är värd för dina Azure OpenAI-modelldistributioner, projektanslutning och agent. Du skapar en projektanslutning som pekar på MCP-slutpunkten för din kunskapsbas och sedan skapar du en agent som använder MCP-verktyget för att komma åt kunskapsbasen.

En användare initierar frågebearbetning genom att interagera med en klientapp, till exempel en chattrobot, som anropar agenten. Agenten använder MCP-verktyget för att samordna begäranden till kunskapsbasen och syntetisera svar. När chattroboten anropar agenten anropar MCP-verktyget kunskapsbasen i Azure AI-sökning och skickar svaret till agenten och chattroboten.

Konfigurera åtkomst

Kontrollera att du har behörighet att komma åt innehåll och åtgärder innan du börjar. Vi rekommenderar Microsoft Entra ID för autentisering och rollbaserad åtkomst för auktorisering. Du måste vara ägare eller administratör för användaråtkomst för att tilldela roller. Om roller inte är genomförbara använder du nyckelbaserad autentisering i stället.

Så här konfigurerar du åtkomst för den här lösningen:

  1. Logga in på Azure-portalen.

  2. Aktivera en systemtilldelad hanterad identitet för både söktjänsten och projektet. Du kan göra det på identitetssidan för varje resurs.

  3. Aktivera rollbaserad åtkomst i söktjänsten och tilldela följande roller.

    Roll Ansvarig Syfte
    Söktjänstdeltagare Ditt användarkonto Skapa objekt
    Sökindexdatabidragare Ditt användarkonto Läsa in data
    Dataläsare för sökindex Ditt användarkonto och din projekthanterade identitet Läsa indexerat innehåll

  4. Tilldela följande roller på projektets överordnade resurs.

    Roll Ansvarig Syfte
    Foundry-användare Ditt användarkonto Åtkomst till modelldistributioner och skapa agenter
    Foundry-projektledare Ditt användarkonto Skapa projektanslutning och använd MCP-verktyget i agenter
    Cognitive Services-användare Hanterad identitet för söktjänst Åtkomst till kunskapsbas

Viktigt

Foundrys RBAC-roller har nyligen namnändrats. Foundry User, Foundry Owner, Foundry Account Owner och Foundry Project Manager hette tidigare Azure AI-användare, Azure AI-ägare, Azure AI-kontoägare och Azure AI Project Manager. Du kanske fortfarande ser de tidigare namnen på vissa platser medan namnbytet distribueras. Roll-ID:na och kärnbehörigheterna ändras inte av namnbytet.

Konfigurera din miljö

  1. Skapa en mapp med namnet tutorial-agentic-retrieval på ditt lokala system.

  2. Öppna mappen i Visual Studio Code.

  3. Välj View>Command Palette och välj sedan Python: Skapa miljö. Följ anvisningarna för att skapa en virtuell miljö.

  4. Välj Terminal>Ny terminal.

  5. Installera de paket som krävs.

    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. Skapa en fil med namnet .env i tutorial-agentic-retrieval mappen.

  7. Lägg till följande variabler i .env filen och ersätt platshållarvärdena med dina egna.

    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

    Du hittar slutpunkterna och resurs-ID:t i Azure portalen:

    • AZURE_SEARCH_ENDPOINT finns på sidan Översikt för söktjänsten.

    • PROJECT_ENDPOINT finns på sidan Slutpunkter i projektet.

    • PROJECT_RESOURCE_ID finns på sidan Egenskaper för projektet.

    • AZURE_OPENAI_ENDPOINT finns på sidan Slutpunkter för projektets överordnade resurs.

  8. Logga in på ditt Azure konto för nyckellös autentisering med Microsoft Entra ID. Om du har flera prenumerationer väljer du den som innehåller dina Azure AI-sökning och Microsoft Foundry-resurser.

    az login

  9. Skapa en fil med namnet tutorial.ipynb i tutorial-agentic-retrieval mappen. Du lägger till kodceller i den här filen i nästa avsnitt.

Skapa lösningen

I det här avsnittet skapar du komponenterna i lösningen för agentisk hämtning. Lägg till varje kodfragment i en separat kodcell i notebook-filen tutorial.ipynb och kör cellerna sekventiellt.

Stegen i det här avsnittet är:

  1. Ladda anslutningar
  2. Skapa ett sökindex
  3. Ladda upp dokument till indexet
  4. Skapa en kunskapskälla
  5. Skapa en kunskapsbas
  6. Konfigurera en projektklient
  7. Skapa en projektanslutning
  8. Skapa en agent med MCP-verktyget
  9. Chatta med agenten
  10. Rensa resurser

Ladda anslutningar

Följande kod läser in miljövariablerna från filen .env och upprättar anslutningar till Azure AI-sökning och 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']

Skapa ett sökindex

I Azure AI-sökning är ett index en strukturerad datasamling. Följande kod skapar ett index för att lagra sökbart innehåll för din kunskapsbas.

Indexschemat innehåller fält för dokumentidentifiering och sidinnehåll, inbäddningar och siffror. Schemat innehåller även konfigurationer för semantisk rangordning och vektorsökning, som använder din text-embedding-3-large distribution för att vektorisera text och matcha dokument baserat på semantisk likhet.

Mer information om det här steget finns i Skapa ett index för agentisk hämtning i Azure AI-sökning.

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")

Ladda upp dokument till indexet

Indexet är för närvarande tomt. Följande kod fyller indexet med JSON-dokument från NASA:s Earth at Night-e-bok. Enligt Azure AI-sökning överensstämmer varje dokument med de fält och datatyper som definierats i indexschemat.

För mer information om det här steget, se Pusha data till ett index.

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}'")

Skapa en kunskapskälla

En kunskapskälla är en återanvändbar referens till källdata. Följande kod skapar en kunskapskälla som riktar sig till det index som du skapade tidigare.

source_data_fields anger vilka indexfält som ingår i källhänvisningar. Det här exemplet innehåller endast fält som kan läsas av människor för att undvika långa, opretenterbara inbäddningar i svar.

Mer information om det här steget finns i Skapa en kunskapskälla för sökindex.

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.")

Skapa en kunskapsbas

Följande kod skapar en kunskapsbas som samordnar agentisk hämtning från din kunskapskälla. Koden lagrar även MCP-slutpunkten för kunskapsbasen, som din agent använder för att komma åt kunskapsbasen.

För integrering med Foundry Agent Service konfigureras kunskapsbasen med följande parametrar:

  • output_mode är inställd på extraherande data, vilket ger agenten ordagrant, obearbetat innehåll för grundande och resonemang. Alternativt läge, svarssyntes, returnerar förgenererade svar som begränsar agentens möjlighet att resonera över källinnehållet.

  • retrieval_reasoning_effort är inställd på minimal ansträngning, vilket kringgår LLM-baserad frågeplanering för att minska kostnader och svarstider. För andra resonemang använder kunskapsbasen en LLM för att omformulera användarfrågor innan de hämtas.

Mer information om det här steget finns i Skapa en kunskapsbas i Azure AI-sökning.

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-05-01-preview"

Konfigurera en projektklient

Använd AIProjectClient för att skapa en klientanslutning till ditt Microsoft Foundry-projekt. Projektet kanske inte innehåller några agenter ännu, men om du redan har slutfört den här självstudien visas agenten här.

from azure.ai.projects import AIProjectClient

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

list(project_client.agents.list())

Skapa en projektanslutning

Följande kod skapar en projektanslutning i Microsoft Foundry som pekar på MCP-slutpunkten för din kunskapsbas. Den här anslutningen använder din projekthanterade identitet för att autenticera mot Azure AI-sökning.

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.")

Skapa en agent med MCP-verktyget

Följande kod skapar en agent som konfigurerats med MCP-verktyget. När agenten tar emot en användarfråga kan den anropa din kunskapsbas via MCP-verktyget för att hämta relevant innehåll för svarsgrundning.

Agentdefinitionen innehåller instruktioner som anger dess beteende och den projektanslutning som du skapade tidigare. Baserat på våra experiment är dessa instruktioner effektiva för att maximera noggrannheten för kunskapsbasanrop och säkerställa korrekt källhänvisningsformatering.

Mer information om det här steget finns i Snabbstart: Skapa en ny agent.

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")

(Valfritt) Framtvinga behörigheter med sidhuvuden per begäran

Om någon av dina kunskapskällor innehåller behörighetsskyddat innehåll kan hämtningsmotorn filtrera resultat så att varje användare bara ser de dokument som de har behörighet att komma åt. Om du vill aktivera den här filtreringen vidarebefordrar du den inloggade användarens identitetstoken i x-ms-query-source-authorization huvudet på MCP-verktygsanslutningen. Utan token returnerar behörighetsaktiverade källor resultat som inte har filtrerats. Mer information finns i Framtvinga behörigheter vid frågetid (förhandsversion).

Om du vill variera MCP-huvuden per begäran, till exempel skicka en annan användares token vid varje anrop, deklarerar du en strukturerad indata i agentdefinitionen och refererar till den som en {{placeholder}} i verktygets headers. Anroparen tillhandahåller värdet för varje anrop. Den här metoden fungerar för MCP-verktyg som är bundna till en projektanslutning.

För auktorisering per användare mot en MCP-server kan du också använda OAuth-identitetsgenomströmning.

Följande kod uppdaterar agenten från föregående steg så att MCP-verktyget läser dess auktoriseringshuvud från en strukturerad indata.

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")

När du anropar agenten anger du en Azure AI-sökning token i structured_inputs. Det här exemplet löser en token från den aktuella credential. För en app för flera användare skickar du token för varje inloggad användare i stället. Använd till exempel en token som hämtats via ett flöde för räkning så att hämtningsmotorn kan filtrera resultaten för användaren.

# 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}")

Chatta med agenten

Klientappen använder API:erna Konversationer och Responses från Azure OpenAI för att interagera med agenten.

Följande kod skapar en konversation och skickar användarmeddelanden till agenten, som liknar en typisk chattupplevelse. Agenten avgör när du ska anropa din kunskapsbas via MCP-verktyget och returnerar ett naturligt språksvar med referenser. Inställningen tool_choice="required" säkerställer att agenten alltid använder kunskapsbasverktyget vid bearbetning av frågor.

# 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}")

Svaret bör likna följande:

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)

Granska svaret

Det underliggande svaret från agenten innehåller metadata om de frågor som skickas till kunskapsbasen och de citat som hittas. Du kan granska dessa metadata för att förstå hur agenten bearbetade användarindata.

response.to_dict()

Rensa resurser

När du arbetar i din egen prenumeration är det en bra idé att slutföra ett projekt genom att ta bort de resurser som du inte längre behöver. Resurser som lämnas igång kan kosta dig pengar.

I Azure-portalen väljer du Alla resurser eller Resource-grupper i den vänstra rutan för att hitta och hantera resurser. Du kan ta bort resurser individuellt eller ta bort resursgruppen för att ta bort alla resurser samtidigt.

Du kan också köra följande kod för att ta bort enskilda objekt:

# 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")

Förbättra datakvaliteten

Som standard konsolideras sökresultat från kunskapsbaser i en stor, enhetlig sträng som du kan skicka vidare till agenter som underlag. Azure AI-sökning innehåller följande indexerings- och relevansjusteringsfunktioner som hjälper dig att generera högkvalitativa resultat. Du kan implementera dessa funktioner i sökindexet, och förbättringarna i sökrelevansen är tydliga i kvaliteten på hämtningssvaren.

  • Bedömningsprofiler erbjuder inbyggda förstärkningskriterier. Ditt index måste ange en standardbedömningsprofil som hämtningsmotorn använder när frågor innehåller fält som är associerade med den profilen.

  • Semantisk konfiguration krävs, men du avgör vilka fält som prioriteras och används för rangordning.

  • För oformaterad text kan du använda analysverktyg för att styra tokenisering under indexering.

  • För multimodalt innehåll eller bildinnehåll kan du använda bildverbalisering för beskrivningar genererade av språkmodeller (LLM) av dina bilder eller klassisk OCR och bildanalys via färdighetsuppsättningar under indexering.

Kontrollera antalet underfrågor

Du kan styra antalet underfrågor genom att ange hämtningsskälet på kunskapsbasen. Resoneringsinsatsen avgör nivån på LLM-bearbetning för sökfrågeplanering, allt från minimal (ingen LLM-bearbetning) till måttlig (djupare sökning och iterationer för fortsättning).

För icke-minimala resonemang bestämmer LLM antalet underfrågor baserat på följande faktorer:

  • Användarfråga
  • Chatthistorik
  • Indatabegränsningar för semantisk rankning

Kontrollera kontexten som skickas till agenten

Svars-API:et styr vad som skickas till agenten och kunskapsbasen. För att optimera prestanda och relevans justerar du agentinstruktionerna för att sammanfatta eller filtrera chatthistoriken innan du skickar den till MCP-verktyget.

Kontrollera kostnader och begränsa åtgärder

Information om frågeplanen finns i utdatatoken i aktivitetsmatrisen för kunskapsbassvar.

Förbättra prestanda

Tänk på följande strategier för att optimera prestanda och minska svarstiden:

  • Sammanfatta meddelandetrådar.

  • Använd gpt-5-mini eller en mindre modell som presterar snabbare.

  • Ställ in maxOutputSize på hämtningsåtgärden för att styra storleken på svaret eller maxRuntimeInSeconds för tidsbunden bearbetning.

  • Dela upp stora dokument i mindre delar före indexering. Dokument som överskrider utdatabudgeten kan tyst utelämnas från grundade resultat.

Relaterat innehåll

  • Last updated on