Tutorial: Membangun solusi pengambilan end-to-end berbasis agen menggunakan Pencarian Azure AI

Pelajari cara membuat solusi cerdas dengan dukungan MCP yang mengintegrasikan Pencarian Azure AI dengan Foundry Agent Service untuk pengambilan agen. Anda dapat menggunakan arsitektur ini untuk aplikasi percakapan yang memerlukan penalaran kompleks atas domain pengetahuan besar, seperti dukungan pelanggan atau pemecahan masalah teknis.

Tutorial ini menggunakan fitur pratinjau REST API di dua tempat. Pangkalan pengetahuan menggunakan output_mode dan retrieval_reasoning_effort (pratinjau) untuk secara eksplisit menentukan output ekstraktif dan penalaran minimal, meskipun perilaku yang setara umumnya tersedia. Koneksi proyek menggunakan RemoteTool (pratinjau) dan identitas terkelola proyek untuk melakukan autentikasi ke layanan Pencarian Azure AI.

Dalam tutorial ini, Anda:

Prasyarat

• Layanan Pencarian Azure AI dalam wilayah mana pun yang menyediakan agentic retrieval.

• Proyek Microsoft Foundry dan sumber daya. Saat Anda membuat proyek, sumber daya dibuat secara otomatis.

• Model penyematan teks yang disebarkan ke proyek Anda untuk vektorisasi waktu kueri. Solusi ini menggunakan text-embedding-3-large.

• Sebuah LLM yang diterapkan pada proyek Anda untuk sebagai agen. Solusi ini menggunakan gpt-5-mini.

  Model keluarga GPT-4 tidak digunakan lagi. Untuk tanggal penghentian dan status saat ini di Microsoft Foundry, lihat Jadwal penghentian model - Microsoft Foundry.

• Izin untuk mengakses dan mengelola sumber daya Pencarian Azure AI dan Microsoft Foundry. Untuk informasi selengkapnya, lihat Mengonfigurasi akses.

• Python 3.8 atau yang lebih baru.

• Visual Studio Code dengan ekstensi Python dan Jupyter.

• Azure CLI untuk autentikasi tanpa kunci dengan Microsoft Entra ID.

Memahami solusinya

Solusi ini menggabungkan Pencarian Azure AI dan Microsoft Foundry untuk menciptakan jalur pengambilan menyeluruh.

• Pencarian Azure AI menghosting pangkalan pengetahuan Anda, yang menangani perencanaan kueri, eksekusi kueri, dan sintesis hasil. Anda membuat indeks pencarian untuk menyimpan konten, sumber pengetahuan yang mereferensikan indeks, dan pangkalan pengetahuan yang melakukan pengambilan hibrid dari sumber pengetahuan.

• Microsoft Foundry menghosting penyebaran model OpenAI, koneksi proyek, dan agen Azure Anda. Anda membuat koneksi proyek yang menunjuk ke titik akhir MCP pangkalan pengetahuan Anda, lalu Anda membuat agen yang menggunakan alat MCP untuk mengakses pangkalan pengetahuan.

Pengguna memulai pemrosesan kueri dengan berinteraksi dengan aplikasi klien, seperti chatbot, yang memanggil agen. Agen menggunakan alat MCP untuk mengatur permintaan ke pangkalan pengetahuan dan mensintesis respons. Ketika chatbot memanggil agen, alat MCP memanggil pangkalan pengetahuan di Pencarian Azure AI dan mengirim respons ke agen dan chatbot.

Mengonfigurasi akses

Sebelum memulai, pastikan Anda memiliki izin untuk mengakses konten dan operasi. Kami merekomendasikan Microsoft Entra ID untuk otentikasi dan akses berbasis peran untuk otorisasi. Anda harus menjadi Pemilik atau Administrator Akses Pengguna untuk menetapkan peran. Jika peran tidak dapat dilakukan, gunakan autentikasi berbasis kunci sebagai gantinya.

Untuk mengonfigurasi akses untuk solusi ini:

1. Masuk ke portal Azure.

2. Aktifkan identitas terkelola yang ditetapkan sistem untuk layanan pencarian dan proyek Anda. Anda dapat melakukannya di halaman Identitas setiap sumber daya.

3. Pada layanan pencarian Anda, aktifkan akses berbasis peran dan tetapkan peran berikut.

   Peran	Penerima Tugas	Tujuan
   Kontributor Layanan Pencarian	Akun pengguna Anda	Membuat objek
   Kontributor Data Indeks Pencarian	Akun pengguna Anda	Memuat data
   Pembaca Data Indeks Pencarian	Akun pengguna dan identitas terkelola proyek Anda	Membaca konten terindeks

4. Pada sumber daya induk proyek Anda, tetapkan peran berikut.

   Peran	Penerima Tugas	Tujuan
   Pengguna Foundry	Akun pengguna Anda	Akses penyebaran model dan membuat agen
   Manajer Proyek Foundry	Akun pengguna Anda	Membuat koneksi proyek dan menggunakan alat MCP di agen
   Pengguna Layanan Kognitif	Identitas terkelola layanan pencarian	Mengakses pangkalan pengetahuan

Mempersiapkan lingkungan Anda

1. Buat folder bernama tutorial-agentic-retrieval pada sistem lokal Anda.

2. Buka folder di Visual Studio Code.

3. Pilih View>Palet Perintah, lalu pilih Python: Buat Lingkungan. Ikuti perintah untuk membuat lingkungan virtual.

4. Pilih Terminal>Terminal Baru.

5. Instal paket yang diperlukan.

   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. Buat file bernama .env di tutorial-agentic-retrieval folder .

7. Tambahkan variabel berikut ke berkas .env, ganti nilai placeholder dengan nilai Anda sendiri.

   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
   

   Anda dapat menemukan titik akhir dan ID sumber daya di portal Azure:

   • AZURE_SEARCH_ENDPOINT ada di halaman Gambaran Umum layanan pencarian Anda.

   • PROJECT_ENDPOINT ada di halaman Titik akhir proyek Anda.

   • PROJECT_RESOURCE_ID ada di halaman Properti proyek Anda.

   • AZURE_OPENAI_ENDPOINT ada di halaman Titik akhir sumber daya induk proyek Anda.

8. Untuk autentikasi tanpa kunci dengan Microsoft Entra ID, masuk ke akun Azure Anda. Jika Anda memiliki beberapa langganan, pilih langganan yang berisi sumber daya Pencarian Azure AI dan Microsoft Foundry Anda.

   az login
   

9. Buat file bernama tutorial.ipynb di tutorial-agentic-retrieval folder . Anda menambahkan sel kode ke file ini di bagian berikutnya.

Membangun solusi

Di bagian ini, Anda membuat komponen solusi pengambilan data agen. Tambahkan setiap cuplikan kode ke sel kode terpisah di tutorial.ipynb buku catatan dan jalankan sel secara berurutan.

Langkah-langkah di bagian ini meliputi:

1. Memuat koneksi
2. Membuat indeks pencarian
3. Mengunggah dokumen ke indeks
4. Membuat sumber pengetahuan
5. Membuat pangkalan pengetahuan
6. Menyiapkan klien proyek
7. Membuat koneksi proyek
8. Membuat agen dengan alat MCP
9. Mengobrol dengan agen
10. Membersihkan sumber daya

Memuat Sambungan

Kode berikut memuat variabel lingkungan dari file .env Anda dan membuat koneksi ke Pencarian Azure AI dan 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']

Membuat indeks pencarian

Dalam Pencarian Azure AI, indeks adalah kumpulan data terstruktur. Kode berikut membuat indeks untuk menyimpan konten yang dapat dicari untuk pangkalan pengetahuan Anda.

Skema indeks berisi bidang untuk identifikasi dokumen dan konten halaman, penyematan, dan angka. Skema ini juga mencakup konfigurasi untuk peringkat semantik dan pencarian vektor, yang menggunakan penyebaran Anda text-embedding-3-large untuk mem-vektorisasi teks dan mencocokkan dokumen berdasarkan kesamaan semantik.

Untuk informasi selengkapnya tentang langkah ini, lihat Buat indeks untuk pengambilan berbasis agen dalam Pencarian Azure AI.

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

Mengunggah dokumen ke indeks

Saat ini, indeks kosong. Kode berikut mengisi indeks dengan dokumen JSON dari NASA's Earth at Night e-book. Seperti yang diperlukan oleh Pencarian Azure AI, setiap dokumen sesuai dengan bidang dan jenis data yang ditentukan dalam skema indeks.

Untuk informasi selengkapnya tentang langkah ini, lihat Mendorong data ke indeks.

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

Membuat sumber pengetahuan

Sumber pengetahuan adalah referensi yang dapat digunakan kembali ke data sumber. Kode berikut membuat sumber pengetahuan yang menargetkan indeks yang sebelumnya Anda buat.

source_data_fields menentukan bidang indeks mana yang disertakan dalam referensi kutipan. Contoh ini hanya mencakup bidang yang mudah dibaca manusia untuk menghindari respons dengan penyematan yang panjang dan tidak dapat diinterpretasikan.

Untuk informasi selengkapnya tentang langkah ini, lihat Membuat sumber pengetahuan indeks pencarian.

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

Membuat pangkalan pengetahuan

Kode berikut membuat basis pengetahuan yang mengoordinasikan pengambilan data dari sumber pengetahuan Anda. Kode ini juga menyimpan titik akhir MCP dari pangkalan pengetahuan, yang akan digunakan agen Anda untuk mengakses pangkalan pengetahuan.

Untuk integrasi dengan Foundry Agent Service, pangkalan pengetahuan dikonfigurasi dengan parameter berikut:

• output_mode (pratinjau) disetel ke data ekstraktif, yang memberikan agen konten verbatim yang belum diproses untuk kontekstualisasi dan penalaran. Mode alternatif, sintesis jawaban, mengembalikan jawaban yang telah dibuat sebelumnya yang membatasi kemampuan agen untuk beralasan atas konten sumber.

• retrieval_reasoning_effort (pratinjau) disetel ke usaha minimum, sehingga melewati perencanaan kueri berbasis LLM untuk mengurangi biaya dan latensi. Untuk upaya penalaran lainnya, pangkalan pengetahuan menggunakan LLM untuk memformulasikan ulang kueri pengguna sebelum pengambilan.

Untuk informasi selengkapnya tentang langkah ini, lihat Buat pangkalan pengetahuan di Pencarian Azure AI.

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"

Menyiapkan klien proyek

Gunakan AIProjectClient untuk membuat koneksi klien ke proyek Microsoft Foundry Anda. Proyek Anda mungkin belum berisi agen apa pun, tetapi jika Anda sudah menyelesaikan tutorial ini, agen tercantum di sini.

from azure.ai.projects import AIProjectClient

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

list(project_client.agents.list())

Membuat koneksi proyek

Kode berikut membuat koneksi proyek RemoteTool (pratinjau) di Microsoft Foundry yang mengarah ke endpoint MCP dari basis pengetahuan Anda. Koneksi ini menggunakan identitas terkelola proyek Anda untuk mengautentikasi ke Pencarian Azure AI.

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

Membuat agen dengan alat MCP

Kode berikut membuat agen yang dikonfigurasi dengan alat MCP. Saat agen menerima kueri pengguna, agen dapat memanggil pangkalan pengetahuan Anda melalui alat MCP untuk mengambil konten yang relevan untuk landasan respons.

Definisi agen mencakup instruksi yang menentukan perilakunya dan koneksi proyek yang sebelumnya Anda buat. Berdasarkan eksperimen kami, instruksi ini efektif dalam memaksimalkan akurasi pemanggilan pangkalan pengetahuan dan memastikan pemformatan kutipan yang tepat.

Untuk informasi selengkapnya tentang langkah ini, lihat Mulai Cepat: Membuat agen baru.

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

(Opsional) Menerapkan izin dengan header per permintaan

Jika salah satu sumber pengetahuan Anda berisi konten yang dilindungi izin, mesin pengambilan dapat memfilter hasil sehingga setiap pengguna hanya melihat dokumen yang diizinkan untuk mereka akses. Untuk mengaktifkan pemfilteran ini, teruskan token identitas pengguna yang masuk di x-ms-query-source-authorization header koneksi alat MCP. Tanpa token, sumber yang diaktifkan izin mengembalikan hasil yang tidak difilter. Untuk informasi selengkapnya, lihat Menerapkan izin pada waktu kueri (pratinjau).

Untuk memvariasikan header MCP per permintaan, seperti meneruskan token pengguna yang berbeda pada setiap panggilan, nyatakan input terstruktur dalam definisi agen dan mereferensikannya sebagai {{placeholder}} di alat headers. Penelepon menyediakan nilai pada setiap pemanggilan. Pendekatan ini berfungsi untuk alat MCP yang terikat pada koneksi proyek.

Untuk otorisasi per pengguna di server MCP, Anda juga dapat menggunakan OAuth identity passthrough.

Kode berikut memperbarui agen dari langkah sebelumnya sehingga alat MCP membaca header otorisasinya dari input terstruktur.

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

Ketika Anda memanggil agen, berikan token Pencarian Azure AI di structured_inputs. Contoh ini menyelesaikan token dari saat ini credential. Untuk aplikasi multiuser, sebagai gantinya teruskan token dari setiap pengguna yang telah login. Misalnya, gunakan token yang diperoleh melalui alur atas nama sehingga mesin pengambilan dapat memfilter hasil untuk pengguna tersebut.

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

Mengobrol dengan agen

Aplikasi klien Anda menggunakan Api Percakapan dan Responses dari Azure OpenAI untuk berinteraksi dengan agen.

Kode berikut membuat percakapan dan meneruskan pesan pengguna ke agen, menyerupan pengalaman obrolan biasa. Agen menentukan kapan harus memanggil pangkalan pengetahuan Anda melalui alat MCP dan mengembalikan jawaban bahasa alami dengan referensi. Pengaturan tool_choice="required" memastikan agen selalu menggunakan alat pangkalan pengetahuan saat memproses kueri.

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

Responsnya harus mirip dengan contoh berikut.

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)

Memeriksa respons

Respons yang mendasari dari agen berisi metadata tentang kueri yang dikirim ke pangkalan pengetahuan dan kutipan yang ditemukan. Anda dapat memeriksa metadata ini untuk memahami bagaimana agen memproses input pengguna.

response.to_dict()

Membersihkan sumber daya

Saat Anda bekerja di langganan Anda sendiri, ada baiknya untuk menyelesaikan proyek dengan menghapus sumber daya yang tidak lagi Anda butuhkan. Sumber daya yang dibiarkan berjalan dapat menyebabkan biaya tambahan.

Di portal Azure, pilih Semua sumber daya atau Kelompok sumber daya dari panel kiri untuk menemukan dan mengelola sumber daya. Anda dapat menghapus sumber daya satu per satu atau menghapus grup sumber daya untuk menghapus semua sumber daya sekaligus.

Anda juga dapat menjalankan kode berikut untuk menghapus objek individual:

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

Meningkatkan kualitas data

Secara default, hasil pencarian dari pangkalan pengetahuan dikonsolidasikan ke dalam string besar dan terpadu yang dapat Anda teruskan ke agen untuk grounding. Pencarian Azure AI menyediakan fitur pengindeksan dan penyetelan relevansi berikut untuk membantu Anda menghasilkan hasil berkualitas tinggi. Anda dapat menerapkan fitur-fitur ini dalam indeks pencarian, dan peningkatan relevansi pencarian terbukti dalam kualitas respons pengambilan.

• Profil penilaian menyediakan kriteria peningkatan bawaan. Indeks Anda harus menentukan profil penilaian default, yang digunakan mesin pengambilan saat kueri menyertakan bidang yang terkait dengan profil tersebut.

• Konfigurasi semantik diperlukan, tetapi Anda menentukan bidang mana yang diprioritaskan dan digunakan untuk peringkat.

• Untuk konten teks biasa, Anda dapat menggunakan penganalisis untuk mengontrol tokenisasi selama pengindeksan.

• Untuk konten multimodal atau gambar, Anda dapat menggunakan verbalisasi gambar untuk deskripsi yang dihasilkan oleh LLM pada gambar Anda atau menggunakan OCR klasik dan analisis gambar melalui skillset selama pengindeksan.

Mengontrol jumlah subkueri

Anda dapat mengontrol jumlah subkueri dengan mengatur upaya penalaran pengambilan (pratinjau) pada pangkalan pengetahuan. Upaya penalaran menentukan tingkat pemrosesan LLM untuk perencanaan kueri, mulai dari minimal (tidak ada pemrosesan LLM) hingga menengah (pencarian yang lebih dalam dan iterasi tindak lanjut).

Untuk upaya penalaran non-minimal, LLM menentukan jumlah subkueri berdasarkan faktor-faktor berikut:

• Kueri pengguna
• Riwayat obrolan
• Pembatasan input pemeringkat semantik

Mengontrol konteks yang dikirim ke agen

API Responses mengontrol apa yang dikirim ke agen dan basis pengetahuan. Untuk mengoptimalkan performa dan relevansi, sesuaikan instruksi agen untuk meringkas atau memfilter riwayat obrolan sebelum mengirimkannya ke alat MCP.

Mengontrol biaya dan membatasi operasi

Untuk wawasan tentang rencana kueri, lihat token output dalam array aktivitas respons pangkalan pengetahuan.

Meningkatkan performa

Untuk mengoptimalkan performa dan mengurangi latensi, pertimbangkan strategi berikut:

• Merangkum percakapan pesan.

• Gunakan gpt-5-mini atau model yang lebih kecil yang berkinerja lebih cepat.

• Atur maxOutputSize pada tindakan ambil untuk mengatur ukuran respons atau maxRuntimeInSeconds untuk pemrosesan terikat waktu.

• Potong dokumen besar menjadi bagian yang lebih kecil sebelum mengindeks. Dokumen yang melebihi anggaran output dapat dihilangkan secara diam-diam dari hasil yang ditetapkan.

Konten terkait

• Pengambilan informasi berbasis Agentic dalam Pencarian Azure AI
• Agentic RAG: Bangun mesin pengambilan penalaran dengan Pencarian Azure AI (video YouTube)
• Demo Azure OpenAI yang menampilkan pengambilan informasi berbasis agen