Explains integrating Azure AI Language with an agent via Foundry and MCP to perform language detection, named entity recognition, and PII redaction while enforcing permissioned, secure workflows
In this lesson you’ll learn how to integrate Azure AI Language capabilities into an AI agent so the agent can better understand, analyze, and safely handle human language. This enables the agent to offload specialized text tasks—like language detection, named entity recognition, and PII redaction—to Azure services instead of implementing them itself.Think of the agent as a smart assistant that reasons and plans, and of tools (like Azure AI Language) as specialized capabilities the agent invokes when needed. In this scenario there are three primary components:
Foundry agent — the agent that interacts with users and decides which actions (tool calls) are needed to complete a task.
MCP server — the Model Context Protocol server provides a standardized way for agents to discover and call tools; it acts as the bridge between the agent and external capabilities.
Azure AI Language — a suite of language-processing services that perform language detection, named entity recognition, PII detection/redaction, and other text analytics.
For example, given the user sentence:
“Alex and I attended a Microsoft AI conference in Las Vegas on September 21st.”the agent can call Azure AI Language to:
detect the language,
extract entities such as names, locations, and dates (named entity recognition),
detect and redact personal data such as email addresses or SSNs (PII detection/redaction).
Delegating these tasks to Azure AI Language ensures higher accuracy, consistent outputs, and reduced risk for the agentic application.
How the agent calls tools
The agent constructs a structured request (a tool invocation) and sends it to the MCP server.
The MCP server routes the request to the configured external capability (Azure AI Language).
The tool returns structured results (e.g., detected language, entity list, redacted text) that the agent uses in its reasoning and responses.
Permission models for tool invocations
When an agent is connected to tools, you must decide how the agent is allowed to invoke them. Choose a model based on trust, security, and the sensitivity of processed data:
Permission Model
Behavior
When to use
One-time
Each tool call requires explicit approval before execution.
High risk or highly sensitive actions (PII redaction, data export).
Always allow for this tool
After initial approval, subsequent calls to the same tool are allowed automatically.
Trusted tools with limited scope and low sensitivity.
Allow all tools
All connected tools may be invoked automatically without future approvals.
Low-risk environments or trusted internal workflows.
Prefer the least-privilege permission model that still enables smooth operation. For workflows that redact or manipulate PII, require at least per-call or per-tool approval.
Example: Named entity extraction
Below is an example of a function-style request payload the agent might send to extract named entities from text:
extract_named_entities_from_text({ "message": "Alex and I attended a Microsoft AI conference. It was in Las Vegas on September 21st.", "inclusionList": [], "exclusionList": [], "overlapPolicy": "MatchLongest", "language": "en"})
Configuring the agent in Foundry
In the Foundry UI you configure the agent’s model, system instructions, and tools. Use the chat/testing pane to interact with and validate the agent’s behavior.Agent configuration checklist:
Model: choose an LLM (for example, GPT-4.1 or GPT-4.1-mini).
Instructions: supply system instructions describing the agent’s role; e.g., “You are a text-analyzing agent. Use Azure Language tools to detect language, identify and redact PII, and return a redacted version of the text.”
Tools: add the Azure Language tool (or other tools) to the agent’s toolset.
Knowledge: optionally attach documents (PDFs, internal docs) the agent can reference for context.
Adding Azure Language to Foundry
To add the Azure Language tool in Foundry:
Choose Add Tools and search the catalog for Azure resources.
Select the Azure Language / Foundry Tools entry and provide the resource name and key.
Example configuration values (wrap these as secure config when adding them):
AzureLanguageinFoundryToolshttps://{foundry-resource-name}.cognitiveservices.azure.com/language/mcp?api-version=2025-11-15-previewOcp-Apim-Subscription-Key: <your-key-here> (or use the 'api-key' header depending on service/version)
Example: PII redaction
A common step is to redact PII before storing or forwarding user content. Here is an example request an agent might invoke to redact PII from a user’s message:
redact_pii_from_text({ "message": "My name is Sarah and my email is sarah@yahoo.com", "piiCategories": [], "excludePiiCategories": [], "redactionPolicy": "CharacterMask", "redactionCharacter": "*", "language": "en", "modelVersion": "latest"})
When the agent invokes redaction, the request will be subject to the configured permission model (one-time, per-tool, or allow-all). After approval, the Azure Language tool returns a sanitized version of the text, and the agent can proceed knowing sensitive data is protected.Simplified example interaction:
User: My name is Sarah and my email is sarah@yahoo.com
Agent: Calling Azure Language redaction…
(redaction request approved)
Agent: I have redacted your personal information for privacy. If you need any help or have questions, feel free to ask!Putting it together: a safe text-processing workflow
A typical workflow when combining tools looks like this:
Agent receives user content.
Agent calls Azure Language to redact PII and/or extract structured data (entities, dates, locations).
Agent stores sanitized data in a database or takes other actions (e.g., search, task automation).
Agent responds to the user, optionally summarizing extracted insights without exposing raw PII.
This pattern keeps sensitive data protected and improves the agent’s analytic accuracy by leveraging Azure’s specialized text-processing capabilities.References and further reading
Conclusion
Integrating Azure AI Language into an agentic architecture lets your agent focus on reasoning and orchestration while delegating text analysis to a specialized service. Use conservative permissions, validate outputs in Foundry’s testing pane, and always sanitize sensitive data before storage or further processing.This concludes the lesson on using language capabilities in an agent.
