Foundry Agent Service gebruiken met LangGraph

Gebruik het langchain-azure-ai pakket om LangGraph- en LangChain-toepassingen te verbinden met Foundry Agent Service. In dit artikel worden praktische scenario's beschreven, van het gebruik van bestaande agents en het samenstellen van multi-agent grafieken tot werkstromen met hulpprogramma's, goedkeuringen met menselijke tussenkomst en tracering.

Voorwaarden

• Een Azure-abonnement. Maak er gratis een.
• Een Foundry-project.
• Een geïmplementeerd chatmodel (bijvoorbeeld gpt-4.1) in uw project.
• Python 3.10 of hoger.
• Azure CLI aangemeld (az login), zodat DefaultAzureCredential kan authenticeren.

Uw omgeving configureren

Installeer het pakket langchain-azure-ai om Microsoft Foundry-mogelijkheden te gebruiken in LangGraph en LangChain.

pip install langchain-azure-ai[tools,opentelemetry] azure-identity

Stel uw omgevingsvariabelen in die we in deze zelfstudie gebruiken:

export AZURE_AI_PROJECT_ENDPOINT="https://<resource>.services.ai.azure.com/api/projects/<project>"
export MODEL_DEPLOYMENT_NAME="gpt-4.1"

Gebruik Foundry Agent Service-agents

De klasse AgentServiceFactory is het startpunt voor het opstellen van agents in LangGraph die communiceren met de agentservice in Foundry. De fabriek maakt LangGraph-compatibele knooppunten die worden uitgevoerd via Agent Service en die kunnen worden gebruikt voor het opstellen van complexere oplossingen met LangGraph.

Maak de agentfactory door de AgentServiceFactory klasse te verbinden met een Foundry-project. Alle agents die u via deze factory maakt of ernaar verwijst, worden beheerd binnen het project en zichtbaar in de Foundry-portal (nieuw).

import os

from langchain_core.messages import HumanMessage

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.agents import AgentServiceFactory
from langchain_azure_ai.utils.agents import pretty_print

factory = AgentServiceFactory(
	project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
	credential=DefaultAzureCredential(),
)	

Een bestaande agent gebruiken

We raden u aan agents te maken en te configureren in de Foundry-portal of Foundry SDK en ze vervolgens bij naam te refereren met get_agent_node om grafieken te componeren. Deze aanpak wordt aanbevolen omdat de configuratie van de agent gecentraliseerd blijft in Foundry en uw code zich kan richten op indeling. U kunt agents ook programmeren met create_prompt_agent wanneer u agents volledig in code moet definiëren.

echo_node = factory.get_agent_node(
	name="my-echo-agent",
	version="latest",
)

Wat dit codefragment doet: Haalt een verwijzing naar een bestaande Foundry-agent op als een knooppunt dat compatibel is met LangGraph. De agent moet al aanwezig zijn in uw Foundry-project. Gebruik version="latest" om altijd de meest recente versie te gebruiken, of zet een specifiek versienummer vast voor stabiliteit.

Testen of uw agent kan draaien:

response = echo_node.invoke(
	{"messages": [HumanMessage(content="Hello, world!")]}
)
pretty_print(response)

================================ Human Message =================================

Hello, world!
================================== Ai Message ==================================
Name: my-echo-agent

Goodbye, world!

Gesprekken en toestand

Knooppunten die zijn gekoppeld aan de agentservice, volgen automatisch reacties in gesprekken. De azure_ai_agents_conversation_id eigenschap wordt toegevoegd aan de status, zodat u kunt verwijzen naar of gesprekken kunt voortzetten:

print(
	"azure_ai_agents_conversation_id:",
	response["azure_ai_agents_conversation_id"],
)

azure_ai_agents_conversation_id: <conversation-id>

Grafieken opstellen met bestaande agents

U kunt agentserviceknooppunten net als elk ander knooppunt in LangGraph gebruiken om complexe grafieken te bouwen. In het volgende voorbeeld wordt een conditionele routeringsgrafiek opgebouwd, waarbij lokaal router_node het gebruikersbericht inspecteert en beslist of het moet worden gedelegeerd aan een Foundry-agent.

from typing import Literal
from langchain_core.messages import AIMessage
from langgraph.graph import StateGraph, MessagesState, START, END


class RouterState(MessagesState):
	jump_to: str | None


def router_node(state: RouterState):
	last_message = state["messages"][-1].content.lower()

	# Simple logic simulating a model decision
	if "negate" in last_message:
		return RouterState(
			messages=state["messages"], jump_to="delegate"
		)
	else:
		return RouterState(
			messages=[AIMessage(content="I can handle this!")],
			jump_to=None,
		)


def route_decision(state: RouterState) -> Literal["expert_node", END]:
	if state.get("jump_to", None) == "delegate":
		return "expert_node"
	return END


workflow = StateGraph(RouterState)

workflow.add_node("router_node", router_node)
workflow.add_node("expert_node", echo_node)
workflow.add_edge(START, "router_node")
workflow.add_conditional_edges("router_node", route_decision)
workflow.add_edge("expert_node", END)

app = workflow.compile()

Wat dit codefragment doet: Hiermee wordt een LangGraph StateGraph met twee knooppunten gebouwd. De router_node inspecteert het laatste bericht — als het 'negate' bevat, delegeert het aan de expert_node (de Foundry-agent opgehaald met get_agent_node). Anders verwerkt de router de aanvraag lokaal en eindigt de grafiek. Dit patroon laat zien hoe u lokale logica combineert met Foundry-agents.

De grafiek ziet er als volgt uit:

Roep de grafiek aan:

print("--- Test 1 (Direct) ---")
pretty_print(
	app.invoke({"messages": [HumanMessage(content="Hello, world!")]})
)

print("\n--- Test 2 (Delegated) ---")
pretty_print(
	app.invoke(
		{"messages": [HumanMessage(content="Negate that I'm a genius!")]}
	)
)

------------------------------- Test 1 (Direct) --------------------------------
================================ Human Message =================================

Hello, world!
================================== Ai Message ==================================

I can handle this!

------------------------------ Test 2 (Delegated) ------------------------------
================================ Human Message =================================

Negate that I'm a genius!
================================== Ai Message ==================================
Name: my-echo-agent

You're not a genius!

In test 1 verwerkt de router de aanvraag lokaal. In Test 2 delegeert de router aan de Foundry-agent, die reageert met het tegenovergestelde van de uitspraak van de gebruiker.

Een eenvoudige promptagent maken

Wanneer u agents volledig in code moet definiëren, bijvoorbeeld tijdens het maken van prototypen of wanneer de agentconfiguratie naast uw toepassing moet worden uitgevoerd, gebruikt create_prompt_agentu . Begin met een minimale promptagent in ReAct-stijl om uw integratie te verifiëren.

agent = factory.create_prompt_agent(
	name="my-echo-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are a helpful AI assistant that always replies with the "
		"opposite of what the user says."
	),
)

print(f"Agent created with ID: {factory.get_agents_id_from_graph(agent)}")

Agent created with ID: {'my-echo-agent:1'}

Roep de agent aan:

messages = [HumanMessage(content="I'm a genius and I love programming!")]
response = agent.invoke({"messages": messages})
pretty_print(response)

================================ Human Message =================================

I'm a genius and I love programming!
================================== Ai Message ==================================
Name: my-echo-agent

You are not a genius and you hate programming!

Wat dit codefragment doet: Hiermee maakt u een op prompt gebaseerde agent in de Foundry Agent-service en retourneert u een LangGraph CompiledStateGraph die deze gebruikt. De agent is onmiddellijk zichtbaar in de Foundry-portal onder Agents. De get_agents_id_from_graph aanroep haalt de door Foundry toegewezen agent-id op, zodat u de agent later kunt bijhouden of ernaar kunt verwijzen.

U kunt visualiseren hoe de agent is gemaakt en gebruikt in de LangGraph-grafiek door de diagramweergave af te drukken. Het knooppunt foundryAgent draait in de Foundry Agent-dienst. U ziet hoe de naam en versie van de agent zichtbaar zijn in de grafiek.

from IPython import display

display.Image(agent.get_graph().draw_mermaid_png())

factory.delete_agent(agent)

Hulpprogramma's toevoegen aan uw software-agent

U kunt hulpprogramma's toevoegen aan uw agent om acties uit te voeren. Met de methode create_prompt_agent wordt de agentlus voor u geïmplementeerd.

U moet twee typen hulpprogramma's onderscheiden:

• Lokale hulpprogramma's: dit zijn tools die lokaal draaien op dezelfde omgeving waar uw agent code wordt uitgevoerd. Ze kunnen aanroepbare functies zijn of elke functie die beschikbaar is voor het Ecosysteem van LangChain/LangGraph.
• Ingebouwde hulpprogramma's: dit zijn hulpprogramma's die uitsluitend kunnen worden uitgevoerd in de Foundry Agent-service; serverzijde. Hulpprogramma's aan de serverzijde kunnen alleen worden toegepast op Foundry-agents.

Als u lokale hulpprogramma's aan uw agent toevoegt, wordt er een hulpprogrammaknooppunt aan uw grafiek toegevoegd, zodat deze hulpprogramma's kunnen worden uitgevoerd. Ingebouwde hulpprogramma's voegen geen hulpprogrammaknooppunt toe en worden uitgevoerd in de service wanneer u een aanvraag indient.

In de volgende sectie wordt uitgelegd hoe u beide kunt gebruiken:

Lokale hulpprogramma's toevoegen

U kunt lokale Python functies definiëren en als hulpprogramma's koppelen. Dit patroon is handig voor deterministische bedrijfslogica en hulpprogrammabewerkingen.

def add(a: int, b: int) -> int:
	"""Add two integers."""
	return a + b


def multiply(a: int, b: int) -> int:
	"""Multiply two integers."""
	return a * b


def divide(a: int, b: int) -> float:
	"""Divide one integer by another."""
	return a / b

Geef de hulpprogramma's door aan de create_prompt_agent functie en roep de agent aan met een rekenkundig probleem met meerdere stappen:

math_agent = factory.create_prompt_agent(
	name="math-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are a helpful assistant tasked with performing arithmetic "
		"on a set of inputs."
	),
	tools=[add, multiply, divide],
)

messages = [
	HumanMessage(
		content="Add 3 and 4. Multiply the output by 2. Divide the output by 5."
	)
]
response = math_agent.invoke({"messages": messages})
pretty_print(response)

================================ Human Message =================================

Add 3 and 4. Multiply the output by 2. Divide the output by 5
================================== Ai Message ==================================
Tool Calls:
  add (call_JSmltOCbsTRkbNEBMAVSgVe1)
 Call ID: call_JSmltOCbsTRkbNEBMAVSgVe1
  Args:
    a: 3
    b: 4
================================= Tool Message =================================
Name: add

7
================================== Ai Message ==================================
Tool Calls:
  multiply (call_ae6M6XyhOIBOkPy3ETd8nDI9)
...
================================== Ai Message ==================================
Name: math-agent

Here's the step-by-step calculation:
1. Add 3 and 4 to get 7.
2. Multiply the result (7) by 2 to get 14.
3. Divide the result (14) by 5 to get 2.8.

The final result is 2.8.

Wat dit codefragment doet: Hiermee maakt u een agent met drie rekenkundige hulpprogramma's. Wanneer de agent bepaalt dat er een aanroep van een hulpprogramma nodig is, organiseert de Foundry Agent Service het aanroepen van het hulpprogramma lokaal en wordt het resultaat teruggezet naar de agent om door te gaan met redeneren.

Gebruik andere hulpprogramma's uit het LangGraph/LangChain-ecosysteem, zoals Azure Document Intelligence in Foundry Tools vanuit dezelfde agentstroom. Hoewel deze hulpprogramma's zijn verbonden met een Foundry-resource, zijn ze niet exclusief voor de agentservice en fungeren ze dus als een lokaal hulpprogramma.

from langchain_azure_ai.tools import AzureAIDocumentIntelligenceTool

document_parser_agent = factory.create_prompt_agent(
	name="document-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions="You are a helpful assistant tasked with analyzing documents.",
	tools=[AzureAIDocumentIntelligenceTool()],
)

Vraag de agent om een factuur van een URL te analyseren:

messages = [
	HumanMessage(
		content=(
			"What's the total amount in the invoice at "
			"https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/"
			"sdk/formrecognizer/azure-ai-formrecognizer/tests/sample_forms/"
			"forms/Form_1.jpg"
		)
	)
]
response = document_parser_agent.invoke({"messages": messages})
pretty_print(response)

================================ Human Message =================================

What's the total amount in ...
================================== Ai Message ==================================
Tool Calls:
  azure_ai_document_intelligence (call_32V6bqeCcJhhsOXDrYFXggnc)
 Call ID: call_32V6bqeCcJhhsOXDrYFXggnc
  Args:
    source_type: url
    source: https://raw.githubusercontent.com/Azure/ ...
================================= Tool Message =================================
Name: azure_ai_document_intelligence

Content: Purchase Order Hero ...
================================== Ai Message ==================================
Name: document-agent

The total amount in the invoice is **$144.00**.

Wat dit codefragment doet: Vraagt de agent om gegevens te extraheren uit een voorbeeldfactuurafbeelding. De agent roept AzureAIDocumentIntelligenceTool aan om het document te parseren en retourneert het resultaat. Verwachte uitvoer: "Het totale bedrag op de factuur is $ 144,00."

Ingebouwde hulpprogramma's toevoegen

Ingebouwde hulpprogramma's in Foundry Agent Service worden server-side uitgevoerd in plaats van in een hulpprogrammaknooppunt zoals lokale hulpprogramma's. Hulpprogramma's in de naamruimte langchain_azure_ai.agents.prebuilt.tools.* zijn alle ingebouwde hulpprogramma's en werken alleen met create_prompt_agent.

Voorbeeld: het hulpprogramma code-interpreter gebruiken

Maak een code-interpreteragent voor gegevensanalyse en roep deze aan met een fictief data.csv gegevensbestand.

Voordat u dit voorbeeld uitvoert, maakt u een lokaal data.csv bestand in uw huidige werkmap.

import base64
from langchain_azure_ai.agents.prebuilt.tools import CodeInterpreterTool

code_interpreter_agent = factory.create_prompt_agent(
	name="code-interpreter-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are a data analyst agent. Analyze CSV data and create "
		"visualizations when helpful."
	),
	tools=[CodeInterpreterTool()],
)

with open("data.csv", "rb") as file_handle:
	csv_data = base64.b64encode(file_handle.read()).decode()

response = code_interpreter_agent.invoke(
	{
		"messages": [
			HumanMessage(
				content=[
					{
						"type": "file",
						"mime_type": "text/csv",
						"base64": csv_data,
					},
					{
						"type": "text",
						"text": (
							"Create a pie chart showing sales by region and "
							"return it as a PNG image."
						),
					},
				]
			)
		]
	}
)
pretty_print(response)

================================ Human Message =================================

[
	{'type': 'file', 'mime_type': 'text/csv', 'base64': '77u/bW9udG...xTb3V0aAo='}, 
	{'type': 'text', 'text': 'create a pie chart with the data showing sales by region and show it to me as a png image.'}
]
================================== Ai Message ==================================
Name: code-interpreter-agent

[
	{'type': 'text', 'text': 'Here is the pie chart showing sales by region as a PNG image:\n\n[Download the Pie Chart](sandbox:/mnt/data/sales_by_region_pie.png)'}, 
	{'type': 'image', 'mime_type': 'image/png', 'base64': 'iVBORw0...ErkJggg=='}
]

Voorbeeld: hulpprogramma voor het genereren van afbeeldingen gebruiken

In het volgende voorbeeld ziet u hoe u ImageGenTool kunt gebruiken voor het genereren van afbeeldingen.

from langchain_azure_ai.agents.prebuilt.tools import ImageGenTool

image_agent = factory.create_prompt_agent(
	name="image-generator-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are an image generation assistant. You receive a text prompt and "
		"must generate an image by using the configured tool."
	),
	tools=[ImageGenTool(model_deployment="gpt-image-1.5", quality="medium")],
)

response = image_agent.invoke(
	{"messages": [HumanMessage("Generate an image of a sunset over mountains.")]}
)
pretty_print(response)

================================ Human Message =================================

Generate an image of a sunset over the mountains.
================================== Ai Message ==================================
Name: image-generator-agent

Andere ingebouwde hulpprogramma's gebruiken

Elk hulpprogramma voor de Foundry Agent-service kan worden gebruikt met create_prompt_agent. Gebruik AgentServiceBaseTool om hulpprogramma's van de AZURE AI Projects SDK te verpakken en deze toe te voegen aan uw promptagent.

Voordat u dit voorbeeld uitvoert, moet u ervoor zorgen dat de vectoropslag-ID bestaat en aanwezig is in uw project.

In het volgende voorbeeld ziet u hoe u een FileSearchTool:

from azure.ai.projects.models import FileSearchTool
from langchain_azure_ai.agents.prebuilt.tools import AgentServiceBaseTool

file_search_agent = factory.create_prompt_agent(
	name="file-search-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are a helpful agent with access to a file search tool over a "
		"vector store."
	),
	tools=[
		AgentServiceBaseTool(
			tool=FileSearchTool(vector_store_ids=["vector-store-1"]),
		)
	],
)

Mens-in-de-lus

Bepaalde hulpprogramma's in Foundry hebben ingebouwde goedkeuringswerkstromen, zoals MCPTool. U kunt goedkeuring vereisen voordat hulpprogramma-aanroepen worden uitgevoerd voor een bepaald hulpprogramma op de server.

De methode create_prompt_agent implementeert hetzelfde patroon dat wordt aanbevolen door LangGraph, door een goedkeuringsknooppunt in de graf toe te voegen.

In het volgende voorbeeld ziet u hoe u met goedkeuring kunt gebruiken MCPTool :

from langchain_azure_ai.agents.prebuilt.tools import MCPTool
from langgraph.checkpoint.memory import MemorySaver
from langgraph.types import Command

mcp_agent = factory.create_prompt_agent(
	name="mcp-github-specs-agent",
	model=os.environ["MODEL_DEPLOYMENT_NAME"],
	instructions=(
		"You are a helpful agent that can use MCP tools to assist users."
	),
	tools=[
		MCPTool(
			server_label="api-specs",
			server_url="https://gitmcp.io/Azure/azure-rest-api-specs",
			require_approval="always",
		)
	],
	checkpointer=MemorySaver(),
)

config = {"configurable": {"thread_id": "mcp-session-1"}}

response = mcp_agent.invoke(
	input={"messages": [HumanMessage("What APIs are available for Azure Cosmos DB?")]},
	config=config,
)
pretty_print(response)

================================ Human Message =================================

What APIs are available for Azure Cosmos DB?
================================== Ai Message ==================================
Tool Calls:
  mcp_approval_request (mcpr_74e314080483acce0069a11d2d9f008190a971212ac61d76d8)
 Call ID: mcpr_74e314080483acce0069a11d2d9f008190a971212ac61d76d8
  Args:
    server_label: api-specs
    name: search_azure_rest_api_docs
    arguments: {"query":"Cosmos DB APIs"}

================================== Interrupt ==================================
Interrupt ID: c3cb23363f91d097298fb3c6f8fbf70a
Interrupt Value:
  Tool Call ID: mcpr_74e314080483acce0069a11d2d9f008190a971212ac61d76d8
  Server Label: api-specs
  Tool Name: search_azure_rest_api_docs
  Arguments: {"query":"Cosmos DB APIs"}

Verzend de goedkeuring met behulp van een Command in LangGraph:

response = mcp_agent.invoke(Command(resume={"approve": True}), config)

pretty_print(response)

================================ Human Message =================================

What APIs are available for Azure Cosmos DB?
================================== Ai Message ==================================
Tool Calls:
  mcp_approval_request (mcpr_74e314080483acce0069a11d2d9f008190a971212ac61d76d8)
 Call ID: mcpr_74e314080483acce0069a11d2d9f008190a971212ac61d76d8
  Args:
    server_label: api-specs
    name: search_azure_rest_api_docs
    arguments: {"query":"Cosmos DB APIs"}
================================= Tool Message =================================

{"approve": true}
================================== Ai Message ==================================
Name: mcp-github-specs-agent

Azure Cosmos DB supports multiple APIs, ...

Observeerbaarheid

Wanneer u oplossingen opstelt met behulp van Foundry Agent Service en LangGraph, worden bepaalde onderdelen uitgevoerd in de agentservice, terwijl anderen uitvoeren waar uw code wordt uitgevoerd.

Met de klasse AzureAIOpenTelemetryTracer kunt u end-to-end-oplossingen traceren die zijn gebouwd met LangGraph met behulp van de OpenTelemetry-standaard, die wordt ondersteund door de agentservice.

Als u uw code wilt traceren, gebruikt u:

from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

tracer = AzureAIOpenTelemetryTracer(
    agent_id="mcp-github-specs-agent-langgraph"
)

mcp_agent = mcp_agent.with_config({ "callbacks": [tracer] })

What dit fragment doet: Maakt een exemplaar van AzureAIOpenTelemetryTracer om traceringen te verzenden naar Azure-toepassing Insights met behulp van de OpenTelemetry-standaard. Hiermee stelt u de parameter agent_id in om traceringen te identificeren door de eigenschap gen_ai.agent.id in spans van het type agent_invoke in te stellen. AzureAIOpenTelemetryTracer vereist een verbindingsreeks voor Azure-toepassing Insights. In dit geval wordt dit niet weergegeven omdat u de omgevingsvariabele AZURE_AI_PROJECT_ENDPOINT instelt, die de klasse kan gebruiken om de verbindingsreeks te detecteren die is gekoppeld aan de Azure-toepassing Insights van het project. U kunt elke gewenste verbindingsreeks doorgeven.

Als u de traceringen wilt bekijken, is het belangrijk om te begrijpen dat er hier twee agents zijn:

1. De Foundry-agent, de back-end van een van de knooppunten van de grafiek.
2. De gehele LangGraph-grafiek, die is samengesteld uit meerdere knooppunten.

U kunt Foundry-agenttraceringen weergeven met behulp van de Foundry-portal, maar als u de tracering van de LangGraph-agent wilt bekijken tijdens het ontwikkelen, moet u Azure Monitor gebruiken in de Azure-portal.

De traceringen weergeven met behulp van Azure Monitor:

1. Ga naar de Azure portal.

2. Navigeer naar Azure-toepassing Insights die u hebt geconfigureerd.

3. Gebruik de linkernavigatiebalk om Onderzoeken>Agents (Preview) te selecteren.

4. U ziet een dashboard met agents, modellen en uitvoeringen van tools. Gebruik deze weergave om inzicht te hebben in de algemene afbeelding van uw agents.

5. Selecteer Traceringen bekijken met agentuitvoeringen. In het zijpaneel ziet u alle traces die zijn gegenereerd door agent-runs.

   

6. Selecteer een van de traces. U zou de details moeten zien.

   

7. U ziet hoe twee agents betrokken zijn bij het gesprek: de agent en de agent foundryAgent met de naam mcp-github-specs-agent-langgraph.

Opschonen van agents

Verwijder agents die u in voorbeelden hebt gemaakt om ongebruikte resources te voorkomen.

Verwijder alleen agents die u in uw sessie hebt gemaakt.

factory.delete_agent(math_agent)	
factory.delete_agent(document_parser_agent)
factory.delete_agent(image_agent)
factory.delete_agent(code_interpreter_agent)
factory.delete_agent(mcp_agent)
factory.delete_agent(file_search_agent)

Probleemoplossing

Gebruik deze controlelijst om veelvoorkomende problemen bij het gebruik van langchain-azure-ai met Agent Service vast te stellen.

Diagnostische logboekregistratie inschakelen

Schakel eerst foutopsporingslogboeken in, zodat u verificatie, aanvraagstroom en details van de uitvoering van hulpprogramma's kunt controleren.

import logging

logging.getLogger("langchain_azure_ai").setLevel(logging.DEBUG)

Als u meer details nodig hebt, verhoog het logniveau om andere bibliotheken op te nemen:

import logging

logging.basicConfig(level=logging.DEBUG)

Configuratie vroeg valideren

• Bevestig AZURE_AI_PROJECT_ENDPOINT wijst naar het juiste projecteindpunt en dat u een Foundry-project gebruikt dat voorzien is van de nieuwe interface.
• Bevestig dat MODEL_DEPLOYMENT_NAME dit overeenkomt met een bestaand geïmplementeerd model.
• Verificatiecontext verifiëren met az account show.
• Gebruik eerst een minimaal create_prompt_agent voorbeeld.

Toegang tot bronnen en machtigingen controleren

• Zorg ervoor dat uw account toegang heeft tot het Foundry-project en de modelimplementatie.
• Zorg ervoor dat downstreamafhankelijkheden (bijvoorbeeld vectorarchieven of hulpprogrammabronnen) bestaan en bereikbaar zijn.
• Als voor een hulpprogramma een specifiek resourcetype is vereist, controleert u of de resource is ingericht in het juiste abonnement en de juiste regio.

Verwante inhoud

• Begin met Microsoft Foundry SDK's en eindpunten
• Traceringsintegraties instellen voor agentframeworks
• Snelstartgids voor Foundry Agent Service
• langchain-azure-ai-pakket in PyPI