Skip to main content

Microsoft Foundry tools integration

This page covers Microsoft Foundry project tools from langchain_azure_ai.tools. See also the tools provided as part of Microsoft Foundry Tools (formerly Azure AI Services).

Use these tools when you want agents to call capabilities in tools provided by Microsoft Foundry projects.

Overview

ToolDescription
AzureOpenAIModelImageGenToolGenerate images through an OpenAI-compatible /images/generations endpoint.
AzureOpenAITranscriptionsToolTranscribe audio files to text through an OpenAI-compatible /audio/transcriptions endpoint.
CodeInterpreterToolRun Python code server-side in a sandboxed container.
WebSearchToolSearch the internet for current information and sources.
FileSearchToolSearch vector stores for relevant document content.
ImageGenerationToolGenerate or edit images using GPT image models.
McpToolAccess external Model Context Protocol (MCP) servers.
AzureAIProjectToolboxLoad tools from an Azure AI Foundry Toolbox and use them via Model Context Protocol (MCP).

Setup

Install dependencies, create the resources used by the tools, and provide credentials.

Installation

Install the integration package:

pipuv

pip install -U "langchain-azure-ai[tools]"

Credentials

Pass either DefaultAzureCredential() or an API-key string through the credential argument (except for AzureAIProjectToolbox which doesn't support keys.)

from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Using Microsoft Entra ID requires the role Azure AI User for the resources where the models are deployed.

Configure endpoints

The tools support two endpoint styles:

  • An Azure AI Foundry project endpoint via project_endpoint or AZURE_AI_PROJECT_ENDPOINT (or FOUNDRY_PROJECT_ENDPOINT).
  • A direct OpenAI-compatible endpoint via endpoint or OPENAI_BASE_URL, for example https://<resource>.services.ai.azure.com/openai/v1.

If both are available, prefer project_endpoint because it resolves the backing service endpoint automatically for Foundry-based workflows.

    export AZURE_AI_PROJECT_ENDPOINT="https://<resource>.services.ai.azure.com/api/projects/<project>"
from azure.identity import DefaultAzureCredential
from langchain_azure_ai.tools import AzureOpenAIModelImageGenTool

tool = AzureOpenAIModelImageGenTool(
    endpoint="https://<resource>.services.ai.azure.com/openai/v1",
    credential=DefaultAzureCredential(),
    model="my-gpt-image-1-deployment",
)

result = tool.invoke(
    {
        "prompt": "A futuristic cityscape at sunset with flying cars",
        "n": 1,
        "size": "1024x1024",
    }
)
print(result)

Tools

AzureOpenAIModelImageGenTool

AzureOpenAIModelImageGenTool (from langchain_azure_ai.tools) generates images using OpenAI-compatible image generation endpoints exposed by Microsoft Foundry Models or Azure OpenAI. You can use models including gpt-image-1.5 or MAI-Image-2.

Use this tool when you want explicit tool invocation for image generation in an agent flow. The tool calls the OpenAI client images.generate API and returns either base64 PNG output or saved file paths when output_directory is configured.

You must deploy an image generation model first, then pass the deployment name in model.

Configuration options

AzureOpenAITranscriptionsTool

AzureOpenAITranscriptionsTool (from langchain_azure_ai.tools) transcribes audio to text using OpenAI-compatible speech-to-text endpoints exposed by Microsoft Foundry Models or Azure OpenAI (such as Whisper).

Use this tool when you want to convert audio files or remote audio URLs into text transcriptions within an agent flow. The tool handles both local files and remote URLs automatically, supporting multiple audio formats (MP3, MP4, MPEG, MPGA, M4A, OGG, FLAC, WAV).

You must deploy a speech-to-text model first, then pass the deployment name in model.

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.tools import AzureOpenAITranscriptionsTool

tool = AzureOpenAITranscriptionsTool(
    endpoint="https://<resource>.services.ai.azure.com/openai/v1",
    credential=DefaultAzureCredential(),
    model="my-whisper-deployment",
)

result = tool.invoke(
    {
        "audio_path": "/path/to/audio.wav",
        "language": "en",
    }
)
print(result)

Configuration options

CodeInterpreterTool

CodeInterpreterTool allows the model to write and execute Python code within a sandboxed container and include the results in its response. This is useful for data analysis, mathematical computations, visualization, and general problem-solving.

Warning

Tools in namespace langchain_azure_ai.tools.builtin must be used with an OpenAI model deployed in a Microsoft Foundry project. They are resolved within the model's inference request and are not available for models running outside Azure AI Foundry.

from langchain_azure_ai.tools.builtin import CodeInterpreterTool

tool = CodeInterpreterTool(
    memory_limit="4g",
)

model_with_code = model.bind_tools([tool])
response = model_with_code.invoke("Plot a sine wave using Python and explain it")
print(response)

Configuration options

WebSearchTool

WebSearchTool allows the model to search the internet for current information and sources related to its queries. This is useful for providing up-to-date information, research, fact-checking, and accessing real-time data.

Warning

Tools in namespace langchain_azure_ai.tools.builtin must be used with an OpenAI model deployed in a Microsoft Foundry project. They are resolved within the model's inference request and are not available for models running outside Azure AI Foundry.

from langchain_azure_ai.tools.builtin import WebSearchTool

tool = WebSearchTool(
    search_context_size="high",
)

model_with_search = model.bind_tools([tool])
response = model_with_search.invoke(
    "What are the latest developments in quantum computing?"
)
print(response)

Configuration options

FileSearchTool

FileSearchTool searches for relevant content from uploaded vector stores. This is useful for retrieving information from large document collections, knowledge bases, and custom data sources that have been indexed in vector stores.

Warning

Tools in namespace langchain_azure_ai.tools.builtin must be used with an OpenAI model deployed in a Microsoft Foundry project. They are resolved within the model's inference request and are not available for models running outside Azure AI Foundry.

from langchain_azure_ai.tools.builtin import FileSearchTool

tool = FileSearchTool(
    vector_store_ids=["vs_abc123", "vs_def456"],
    max_num_results=5,
)

model_with_search = model.bind_tools([tool])
response = model_with_search.invoke(
    "Find information about company policies on remote work"
)
print(response)

Configuration options

ImageGenerationTool

ImageGenerationTool allows the model to generate or edit images using GPT image models. This is useful for creating visuals, editing images, and generating artwork based on text descriptions. This tool must be used with an OpenAI model deployed in a Microsoft Foundry project. If you are using another model, use AzureOpenAIModelImageGenTool instead.

Warning

Tools in namespace langchain_azure_ai.tools.builtin must be used with an OpenAI model deployed in a Microsoft Foundry project. They are resolved within the model's inference request and are not available for models running outside Azure AI Foundry.

from langchain_azure_ai.tools.builtin import ImageGenerationTool

tool = ImageGenerationTool(
    quality="high",
    size="1024x1024",
    model_deployment="my-gpt-image-1-deployment",
)

model_with_images = model.bind_tools([tool])
response = model_with_images.invoke(
    "Generate an image of a futuristic city with flying cars"
)
print(response)

Configuration options

McpTool

McpTool gives the model access to an external Model Context Protocol (MCP) server. This allows the model to call tools exposed by remote MCP servers within a single conversational turn, enabling integration with custom services and external systems.

Warning

Tools in namespace langchain_azure_ai.tools.builtin must be used with an OpenAI model deployed in a Microsoft Foundry project. They are resolved within the model's inference request and are not available for models running outside Azure AI Foundry.

from langchain_azure_ai.tools.builtin import McpTool

tool = McpTool(
    server_label="my_mcp_server",
    server_url="https://my-mcp-server.example.com",
    allowed_tools=["tool_1", "tool_2"],
)

model_with_mcp = model.bind_tools([tool])
response = model_with_mcp.invoke(
    "Use the MCP server to retrieve user profile information"
)
print(response)

Configuration options

Toolboxes

Setup

Install required dependencies:

pipuv

pip install -U "langchain-azure-ai[tools]" langchain-mcp-adapters httpx

AzureAIProjectToolbox

AzureAIProjectToolbox (from langchain_azure_ai.tools) loads tools from an Azure AI Foundry Toolbox and makes them available via the Model Context Protocol (MCP).

Azure AI Foundry Toolbox is a managed multi-MCP server that aggregates multiple configured tools behind a single MCP endpoint. Use this when you want to dynamically load and use a collection of tools from your Azure AI Foundry project in an agent.

The toolbox automatically handles:

  • Azure Identity Bearer-token authentication
  • Graceful OAuth consent-error handling: returns a fallback tool with the consent URL instead of raising
  • Automatic tool-schema sanitization for MCP servers that emit incomplete JSON schemas

Create a toolbox in your Microsoft Foundry project. For documentation see Toolbox in Foundry.

Configuration parameters

Basic usage

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.tools import AzureAIProjectToolbox
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage

async def main():
    toolbox = AzureAIProjectToolbox(
        project_endpoint="https://<resource>.services.ai.azure.com/api/projects/<project>",
        toolbox_name="my-toolbox",
    )
    tools = await toolbox.get_tools()

    model = init_chat_model("azure_ai:gpt-5-mini", credential=DefaultAzureCredential())
    agent = create_agent(
        model=model,
        tools=tools,
    )

    result = await agent.ainvoke({
        "messages": [HumanMessage("What can you do with the available tools?")]
    })
    return result

Or use environment variables instead:

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

Then instantiate without arguments (or just toolbox_name):

from langchain_azure_ai.tools import AzureAIProjectToolbox

toolbox = AzureAIProjectToolbox(toolbox_name="my-toolbox")
tools = await toolbox.get_tools()

Using async context manager

async with is supported for ergonomic compatibility:

async with AzureAIProjectToolbox(toolbox_name="my-toolbox") as toolbox:
    tools = await toolbox.get_tools()

Integration with agents

The get_tools() method returns a list of BaseTool instances ready for use with any LangChain agent pattern:

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.tools import AzureAIProjectToolbox
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model

async def main():
    credential = DefaultAzureCredential()
    toolbox = AzureAIProjectToolbox(
        toolbox_name="my-toolbox",
        credential=credential,
    )

    tools = await toolbox.get_tools()

    model = init_chat_model("azure_ai:gpt-5-mini", credential=credential)
    agent = create_agent(
        model=model,
        tools=tools,
        system_prompt=(
            "You are a helpful assistant with access to a set of tools from "
            "Azure AI Foundry. Use them to help the user with their requests."
        ),
    )

    return agent

API reference

from langchain_azure_ai.tools import (
    AzureAIProjectToolbox,
    AzureOpenAIModelImageGenTool,
    AzureOpenAITranscriptionsTool,
)
from langchain_azure_ai.tools.builtin import (
    CodeInterpreterTool,
    FileSearchTool,
    ImageGenerationTool,
    McpTool,
    WebSearchTool,
)