Użyj usługi agenta Foundry z LangGraph

Użyj pakietu langchain-azure-ai, aby połączyć aplikacje LangGraph i LangChain z usługą Agenta Foundry. W tym artykule przedstawiono praktyczne scenariusze, od używania istniejących agentów do tworzenia wielosagentowych grafów, przepływów pracy wspieranych narzędziami, zatwierdzeń z udziałem człowieka i śledzenia.

Wymagania wstępne

  • Subskrypcja Azure. Utwórz je bezpłatnie.
  • Projekt Foundry.
  • Wdrożony model czatu (na przykład gpt-4.1) w projekcie.
  • Python 3.10 lub nowsza.
  • Azure CLI jest zalogowane (az login), więc DefaultAzureCredential może się uwierzytelnić.

Niektóre przykłady wymagają dodatkowych zasobów:

Konfigurowanie środowiska

Zainstaluj pakiet langchain-azure-ai, aby używać funkcji Microsoft Foundry w języku LangGraph i LangChain.

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

Sprawdź wersję Python, instalację pakietu i logowanie Azure:

python --version
python -c "import langchain_azure_ai; print('langchain-azure-ai is installed')"
az account show --output table

Wskazówka

Zainstaluj dodatki [tools], aby używać narzędzi takich jak analiza dokumentów lub łączniki Azure Logic Apps. Zainstaluj [opentelemetry] aby uwzględnić obsługę OpenTelemetry z konwencjami semantycznymi dla rozwiązań generatywnej sztucznej inteligencji.

Ustaw zmienne środowiskowe, które są używane w tym samouczku:

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

Korzystanie z agentów usługi Foundry Agent Service

Klasa AgentServiceFactory to punkt wyjścia do tworzenia agentów w języku LangGraph, którzy wchodzą w interakcję z usługą agenta w narzędziu Foundry. Fabryka tworzy węzły kompatybilne z LangGraph, które działają przez usługę Agent i mogą być używane do komponowania bardziej złożonych rozwiązań z LangGraph.

Utwórz fabrykę agentów, łącząc klasę AgentServiceFactory z projektem Foundry. Wszyscy agenci, których tworzysz lub do których się odwołujesz za pośrednictwem tej fabryki, są zarządzani w projekcie i widoczni w portalu Foundry (nowym).

Uwaga

Migrowanie z wersji klasycznej usługi Foundry: Agenci utworzone za pomocą langchain_azure_ai.agents.v1.AgentServiceFactory programu są widoczne tylko w portalu Foundry (klasycznym).

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(),
)

Korzystanie z istniejącego agenta

Zalecamy tworzenie i konfigurowanie agentów w portalu Foundry lub zestawie SDK rozwiązania Foundry, a następnie odwoływanie się do nich po nazwie z get_agent_node w celu komponowania grafów. To podejście jest zalecane, ponieważ utrzymuje konfigurację agenta scentralizowaną w narzędziu Foundry i umożliwia skoncentrowanie się na orkiestracji kodu. Możesz również tworzyć agentów programowo z create_prompt_agent, gdy trzeba zdefiniować agentów w całości w kodzie.

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

Co robi ten fragment kodu: Pobiera odwołanie do istniejącego agenta foundry jako węzła zgodnego z językiem LangGraph. Ten agent musi już istnieć w twoim projekcie Foundry. Użyj polecenia version="latest" , aby zawsze wskazać najnowszą wersję lub przypiąć określony numer wersji w celu zapewnienia stabilności.

Przetestuj, czy agent może uruchomić:

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

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

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

Goodbye, world!

Konwersacje i stan

Węzły dołączone do usługi agenta automatycznie śledzą odpowiedzi w konwersacjach. Właściwość azure_ai_agents_conversation_id jest dodawana do stanu, aby można było odwoływać się do konwersacji lub kontynuować konwersacje:

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

azure_ai_agents_conversation_id: <conversation-id>

Tworzenie grafów przy użyciu istniejących agentów

Do tworzenia złożonych grafów można użyć węzłów usługi agenta, podobnie jak w przypadku każdego innego węzła w języku LangGraph. Poniższy przykład tworzy graf routingu warunkowego, w którym lokalny router_node sprawdza komunikat użytkownika i decyduje, czy delegować do agenta Foundry.

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

Co robi ten fragment kodu: Tworzy język LangGraph StateGraph z dwoma węzłami. router_node kontroluje ostatni komunikat — jeśli zawiera on słowo "negate", deleguje go do expert_node (agent Foundry pobrany za pomocą get_agent_node). W przeciwnym razie router obsługuje żądanie lokalnie i kończy graf. Ten schemat pokazuje, jak połączyć logikę lokalną z agentami Foundry.

Wykres wygląda następująco:

Diagram grafu agenta z węzłem uruchomionym w Usłudze Agenta.

Wywołaj graf:

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!

W teście 1 router obsługuje żądanie lokalnie. W teście 2 router deleguje agenta foundry, który odpowiada odwrotnie od instrukcji użytkownika.

Tworzenie podstawowego agenta wywołania

Jeśli musisz zdefiniować agentów w całości w kodzie — na przykład podczas tworzenia prototypów lub gdy konfiguracja agenta powinna działać razem z aplikacją — użyj polecenia create_prompt_agent. Zacznij od minimalnego agenta monitu w stylu react, aby zweryfikować integrację.

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

agent_ids = factory.get_agents_id_from_graph(agent)
print(f"Agent created: {next(iter(agent_ids))}")

Agent created: my-echo-agent:1

Wywołaj agenta:

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!

Co robi ten fragment kodu: Tworzy agenta opartego na promptach w usłudze agenta Foundry i zwraca LangGraph CompiledStateGraph, który go używa. Agent jest natychmiast widoczny w portalu Foundry w obszarze Agenci. Metoda factory.get_agents_id_from_graph pobiera nazwę i wersję agenta przypisanego przez narzędzie Foundry z skompilowanego grafu.

Możesz zwizualizować sposób tworzenia i użycia agenta w grafie LangGraph, drukując jego reprezentację diagramu. Węzeł foundryAgent jest uruchamiany w usłudze Foundry Agent Service. Zwróć uwagę, że nazwa i wersja agenta są widoczne na grafie.

from IPython import display

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

factory.delete_agent(agent)

Diagram wykresu agenta dla agenta bez narzędzi.

Dodawanie narzędzi do agenta

Możesz dodać narzędzia do swojego agenta, aby wykonywać akcje. Metoda create_prompt_agent implementuje pętlę agenta dla Ciebie.

Należy odróżnić dwa typy narzędzi:

  • Narzędzia lokalne: Są to narzędzia działające w tym samym miejscu, co kod agenta. Mogą one być funkcjami wywoływanymi lub dowolną funkcją dostępną dla ekosystemu LangChain/LangGraph.
  • Wbudowane narzędzia: są to narzędzia, które można uruchamiać wyłącznie w usłudze agenta Foundry; po stronie serwera. Narzędzia po stronie serwera można stosować tylko do agentów usługi Foundry.

Dodanie narzędzi lokalnych do agenta powoduje dodanie węzła narzędzia do grafu, w którym te narzędzia mają być uruchamiane. Wbudowane narzędzia nie dodają węzła narzędzia i są wykonywane w usłudze, kiedy składasz żądanie.

Diagram wykresu agenta dla agenta z narzędziami.

W poniższej sekcji wyjaśniono, jak używać obu tych elementów:

Dodawanie narzędzi lokalnych

Funkcje Python lokalne można definiować i dołączać je jako narzędzia. Ten wzorzec jest przydatny w przypadku deterministycznej logiki biznesowej i operacji narzędziowych.

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

Przekaż narzędzia do funkcji create_prompt_agent i użyj agenta do rozwiązania wieloetapowego problemu arytmetycznego.

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.

Co robi ten fragment kodu: Tworzy agenta z trzema narzędziami arytmetycznymi. Gdy agent określi, że wymagane jest wywołanie narzędzia, Usługa Agenta Foundry koordynuje wywołanie narzędzia lokalnie i przekazuje wynik z powrotem do agenta, aby kontynuować wnioskowanie.

Użyj innych narzędzi z ekosystemu LangGraph/LangChain, takich jak Azure Document Intelligence w Foundry Tools w tym samym przepływie agenta. Chociaż te narzędzia są połączone z zasobem usługi Foundry, nie są one wyłączne dla usługi agenta i dlatego działają jak narzędzie lokalne.

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()],
)

Wskazówka

AzureAIDocumentIntelligenceTool może używać projektu Foundry do nawiązywania połączenia z usługą, a także obsługiwać Microsoft Entra na potrzeby uwierzytelniania. Domyślnie narzędzie używa AZURE_AI_PROJECT_ENDPOINT razem z DefaultAzureCredential, dlatego nie jest potrzebna żadna dalsza konfiguracja. Możesz to zmienić, aby w razie potrzeby użyć określonego punktu końcowego i klucza.

Poproś agenta o przeanalizowanie faktury z adresu URL:

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**.

Co robi ten fragment kodu: Prosi agenta o wyodrębnienie danych z przykładowego obrazu faktury. Agent wywołuje AzureAIDocumentIntelligenceTool do analizy dokumentu i zwraca wynik. Oczekiwane dane wyjściowe: "Łączna kwota na fakturze wynosi 144,00 USD".

Dodawanie wbudowanych narzędzi

Wbudowane narzędzia w usłudze agenta programu Foundry działają na serwerze, a nie w węźle narzędzia takich jak narzędzia lokalne. Narzędzia w przestrzeni nazw langchain_azure_ai.agents.prebuilt.tools.* to wszystkie wbudowane narzędzia i działają tylko z create_prompt_agent.

Przykład: użyj narzędzia interpretera kodu

Utwórz agenta interpretera kodu na potrzeby analizy danych i wywołaj go fikcyjnym plikiem data.csv danych.

Przed uruchomieniem tego przykładu utwórz plik lokalny data.csv w bieżącym katalogu roboczym.

region,sales
North,120
South,80
East,100
West,60

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=='}
]

Obraz wygenerowany przez

Przykład: korzystanie z narzędzia do generowania obrazów

Przed uruchomieniem tego przykładu upewnij się, że projekt ma wdrożenie o nazwie gpt-image-1.5. W poniższym przykładzie pokazano, jak używać ImageGenTool do generowania obrazów:

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

Obraz wygenerowany przez element

Korzystanie z innych wbudowanych narzędzi

Dowolne narzędzie usługi agenta programu Foundry może być używane z usługą create_prompt_agent. Użyj AgentServiceBaseTool, aby opakowować narzędzia z zestawu SDK projektów sztucznej inteligencji Azure i dołączyć je do agenta monitu.

Przed uruchomieniem tego przykładu upewnij się, że w projekcie istnieje identyfikator magazynu wektorów. Ustaw identyfikator jako zmienną środowiskową:

export VECTOR_STORE_ID="<vector-store-id>"

W poniższym przykładzie pokazano, jak używać elementu 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=[os.environ["VECTOR_STORE_ID"]]
			),
		)
	],
)

print(factory.get_agents_id_from_graph(file_search_agent))

{'file-search-agent:1'}

Pętla człowiek w pętli

Niektóre narzędzia w rozwiązaniu Foundry mają wbudowane przepływy pracy zatwierdzania, takie jak MCPTool. Można ustawić wymóg zatwierdzenia przed wykonaniem wywołań danego narzędzia na serwerze.

Metoda create_prompt_agent implementuje ten sam wzorzec zalecany przez langgraph, wprowadzając węzeł zatwierdzania na grafie:

Diagram wykresu agenta dla agenta z zaimplementowanymi przepływami zatwierdzania.

W poniższym przykładzie pokazano, jak używać MCPTool za pomocą zatwierdzenia:

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=(
		"Use the available MCP tool to answer every request. "
		"Don't answer from your existing knowledge."
	),
	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(
				"Use the MCP tool to find the APIs available for Azure Cosmos DB."
			)
		]
	},
	config=config,
)
pretty_print(response)

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

Use the MCP tool to find the APIs 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"}

Wyślij zatwierdzenie przy użyciu elementu Command in LangGraph:

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

pretty_print(response)

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

Use the MCP tool to find the APIs 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, ...

Możliwość obserwowania

Podczas tworzenia rozwiązań przy użyciu Foundry Agent Service i LangGraph, niektóre elementy są uruchamiane w usłudze agenta, podczas gdy inne działają tam, gdzie wykonywany jest twój kod.

Klasa AzureAIOpenTelemetryTracer umożliwia śledzenie rozwiązań kompleksowych utworzonych za pomocą LangGraph przy użyciu standardu OpenTelemetry, co jest obsługiwane przez Usługę Agenta.

Aby śledzić kod, użyj:

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]})

Jak ten fragment kodu wykonuje następujące działania: Tworzy wystąpienie AzureAIOpenTelemetryTracer w celu wysyłania śladów do usługi aplikacja systemu Azure Insights przy użyciu standardu OpenTelemetry. Ustawia parametr agent_id w celu zidentyfikowania śladów, ustawiając właściwość gen_ai.agent.id w zakresach typu agent_invoke. AzureAIOpenTelemetryTracer wymaga ciągu połączenia do aplikacja systemu Azure Insights. W takim przypadku nie jest wyświetlany, ponieważ ustawiono zmienną środowiskową AZURE_AI_PROJECT_ENDPOINT, której klasa może użyć do wykrywania ciągu połączenia do aplikacja systemu Azure Insights skojarzonego z projektem. Możesz przekazać dowolny potrzebny ciąg połączenia.

Aby wyświetlić ślady, ważne jest, aby zrozumieć, że w tym miejscu istnieją dwa agenty :

  1. Agent Foundry, który jest zapleczem jednego z węzłów grafu.
  2. Cały graf LangGraph, który składa się z wielu węzłów.

Możesz wyświetlić ślady agenta foundry przy użyciu portalu Foundry ale aby wyświetlić ślad agenta LangGraph podczas opracowywania, należy użyć Azure Monitor w portalu Azure.

Wskazówka

Aplikacje LangChain i LangGraph można zarejestrować w Foundry Control Plane do zarządzania. Następnie możesz użyć portalu Foundry do wyświetlania śladów. Sprawdź Śledzenie w warstwie sterowania Foundry.

Aby wyświetlić ślady przy użyciu Azure Monitor:

  1. Przejdź do portalu Azure.

  2. Przejdź do skonfigurowanego rozwiązania aplikacja systemu Azure Insights.

  3. Korzystając z lewego paska nawigacyjnego, wybierz pozycję Zbadaj>Agentów (wersja zapoznawcza).

  4. Widzisz pulpit nawigacyjny pokazujący agentów, modele i działania narzędzi. Użyj tego widoku, aby zrozumieć ogólny obraz agentów.

  5. Wybierz Opcję Wyświetl ślady z działaniami agenta. Na panelu bocznym są wyświetlane wszystkie ślady generowane przez przebiegi agenta.

    Zrzut ekranu przedstawiający sekcję Agenci (wersja zapoznawcza) w Azure Monitor wyświetlający wiele przebiegów.

  6. Wybierz jeden ze śladów. Powinieneś zobaczyć szczegóły.

    Zrzut ekranu przedstawiający szczegóły śledzenia wybranego przebiegu.

  7. Zwróć uwagę, że dwóch agentów jest zaangażowanych w konwersację: agenta foundryAgent i jednego o nazwie mcp-github-specs-agent-langgraph.

Czyszczenie agentów

Usuń agentów utworzonych w próbkach, aby uniknąć pozostawiania nieużywanych zasobów.

Usuń tylko agentów utworzonych w sesji.

for variable_name in (
	"math_agent",
	"document_parser_agent",
	"image_agent",
	"code_interpreter_agent",
	"mcp_agent",
	"file_search_agent",
):
	created_agent = locals().get(variable_name)
	if created_agent is not None:
		factory.delete_agent(created_agent)

Ważne

Po usunięciu obiektu LangGraph nie można już używać.

Rozwiązywanie problemów

Ta lista kontrolna służy do diagnozowania typowych problemów podczas korzystania langchain-azure-ai z usługi agenta.

Włączanie rejestrowania diagnostycznego

Włącz najpierw dzienniki debugowania, aby można było sprawdzić uwierzytelnianie, przepływ żądań i szczegóły wykonywania narzędzia.

import logging

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

Jeśli potrzebujesz więcej szczegółów, zwiększ rejestrowanie, aby uwzględnić inne biblioteki:

import logging

logging.basicConfig(level=logging.DEBUG)

Wczesne weryfikowanie konfiguracji

  • Upewnij się, że AZURE_AI_PROJECT_ENDPOINT wskazuje prawidłowy punkt końcowy projektu i używasz projektu Foundry z nowym interfejsem.
  • Potwierdź MODEL_DEPLOYMENT_NAME pasuje do istniejącego wdrożonego modelu.
  • Zweryfikuj kontekst uwierzytelniania za pomocą polecenia az account show.
  • Najpierw użyj minimalnego przykładu create_prompt_agent.

Weryfikowanie dostępu do zasobów i uprawnień

  • Upewnij się, że Twoje konto ma dostęp do projektu Foundry i wdrożenia modelu.
  • Upewnij się, że zależności podrzędne (na przykład magazyny wektorów lub zasoby narzędzi) istnieją i są osiągalne.
  • Jeśli narzędzie wymaga określonego typu zasobu, sprawdź, czy zasób jest aprowizowany w odpowiedniej subskrypcji i regionie.

Rozwiąż błędy wykonywania narzędzia

  • Jeśli interpreter kodu zwraca 400 odpowiedź, spróbuj ponownie wysłać żądanie. Jeśli błąd będzie nadal występował, upewnij się, że region projektu i model czatu obsługują interpreter kodu.
  • Jeśli generowanie obrazu zwróci DeploymentNotFound, wdróż gpt-image-1.5 w projekcie lub zaktualizuj model_deployment do nazwy istniejącego wdrożenia modelu generowania obrazów.
  • Jeśli żądanie MCP nie zostanie wstrzymane do zatwierdzenia, upewnij się, że monit jawnie wymaga użycia narzędzia MCP. Zatwierdzenie odbywa się tylko wtedy, gdy model wybierze narzędzie.

Używaj Foundry Memory z bibliotekami LangChain i LangGraph

Powiązana zawartość

  • Last updated on