Artificial intelligence powered by large language models (LLMs) has revolutionized developer workflows, but integrating them reliably into production pipelines remains complex. Too often, teams waste valuable time building scaffolding for JSON parsing, web crawling, search-and-fetch tooling, and internal system connectors — all essential plumbing but not differentiators for their business.

Microsoft Foundry’s recent update dramatically shifts this paradigm by embedding five powerful Claude capabilities directly into their hosted Azure platform. These features transform a basic model call into a robust production agent environment — cutting undifferentiated engineering, ensuring data residency, and simplifying integrations with enterprise systems.

In this post, we explore these five capabilities: Structured Outputs, Web Search, Web Fetch, MCP Connector, and Tool Search. We'll dissect their impact on system architecture, dive into practical use cases, and provide code examples demonstrating how to get started with the new Anthropic Foundry SDKs in Python and TypeScript.

Architecture Overview

┌─────────────────────────────────────────────┐
│          Enterprise Data & Systems           │
├─────────────────────────────────────────────┤
│  • Databases                                │
│  • Documents & Knowledge Bases              │
│  • Operational Systems (Jira, ServiceNow)  │
└─────────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────────┐
│       Microsoft Foundry Platform on Azure    │
├─────────────────────────────────────────────┤
│  • Hosted Claude Model Endpoints             │
│  • Structured Outputs & JSON Schema Enforced│
│  • Web Search & Web Fetch Tools              │
│  • MCP Connector for Systems of Record       │
│  • Tool Search Router & Governance           │
└─────────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────────┐
│                Enterprise Applications       │
├─────────────────────────────────────────────┤
│  • AI-Powered Assistants & Agents            │
│  • Automation Workflows                       │
│  • Customer-Facing AI Experiences             │
└─────────────────────────────────────────────┘

This architecture tightly integrates Claude's powerful AI capabilities with enterprise data sources and operational tools, all running within Azure’s compliant cloud infrastructure. Enterprises now have a turnkey, agent-ready platform supporting compliance, security, observability, and resiliency.

Claude models hosted on Azure in Microsoft Foundry, courtesy of Microsoft Foundry Blog

Key Technical Observations

• Breaking the JSON.parse() Roulette — Structured outputs integrate JSON Schema constraints directly into Claude’s token generation, eliminating the headaches of invalid or malformed JSON in downstream data pipelines.

• Dynamic Token-Efficient Web Search — The new programmable tool calling allows Claude to execute filtered web searches dynamically, significantly reducing token waste from irrelevant boilerplate or navigation text.

• Combined Web Search and Fetch for Breadth and Depth — The synergy of web search delivering promising URLs, followed by web fetch reading full documents, enables powerful research scenarios with explicit citation support.

• MCP Connector Bridges Models to Enterprise Systems Without Client Logic — Direct MCP server integration from the Foundry API removes the need for bespoke tooling libraries to connect to Jira, ServiceNow, Confluence, or custom internal APIs.

• Tool Search Scales Agent Tooling Beyond Hundreds of Tools — Tool routing uses search-based matching (regex or BM25) to dynamically select from large tool sets, bypassing traditional tool confusion when scale grows.

• Azure-Native Hosting Removes the Capability-Compliance Tradeoff — Hosting Claude fully on Azure ensures that enterprises can meet data residency and governance requirements while unlocking agentic features previously available only on Anthropic infrastructure.

How It Works

1. Structured Outputs: Enforcing Reliable JSON Contracts

Teams processing data at scale typically struggle with unpredictable JSON from an LLM, leading to manual retry loops like this common Python pattern:

for attempt in range(3):
    raw = call_model(prompt)
    try:
        data = json.loads(raw)
        validate(data)
        break
    except (json.JSONDecodeError, ValidationError):
        prompt += "\n\nYour last response was invalid JSON. Try again."

This approach creates costly error queues and manual triage.

Microsoft Foundry’s Structured Outputs use a JSON Schema grammar to restrict token generation, guaranteeing valid output. This also extends to tool inputs by ensuring schema-valid calls when invoking tools.

Python example for claims intake extraction:

from pydantic import BaseModel
from typing import Literal
from anthropic import AnthropicFoundry

class ClaimIntake(BaseModel):
    policy_number: str
    claimant_name: str
    loss_date: str  # ISO 8601
    loss_type: Literal[
        "property_damage", "bodily_injury", "business_interruption",
        "auto_liability", "other",
    ]
    estimated_severity_usd: float
    third_party_involved: bool
    injuries_reported: bool
    summary: str
    escalate_to_adjuster: bool

client = AnthropicFoundry(resource="contoso-ai")

response = client.messages.parse(
    model="claude-opus-5",
    max_tokens=2048,
    system=(
        "You are a claims intake analyst. Extract only what is stated or "
        "clearly implied in the submission. If severity is not stated, "
        "estimate conservatively from comparable losses."
    ),
    messages=[{"role": "user", "content": submission_text}],
    output_format=ClaimIntake,
)

claim = response.parsed_output
if claim.escalate_to_adjuster:
    enqueue_for_adjuster(claim)

This pattern enforces correctness at generation, sparing your pipeline endless parsing retries and exceptions.

2. Web Search: Seamless, Verified, Token-Efficient Retrieval

Claude’s new Web Search tool is used by simply adding it to the tool array and specifying usage limits:

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "What's the current state of the EU AI Act's GPAI obligations?"}],
    tools=[{"type": "web_search_20250305", "name": "web_search", "max_uses": 5}],
)

The model autonomously decides when to query the web and attaches citations with specific source spans.

With newer versions ( >20260209), Claude uses internal code execution to dynamically pre-filter results before inclusion in the prompt, drastically reducing wasted token context from irrelevant content. This turns web search into a far more efficient research assistant.

Use case: A global bank monitors regulatory changes in 12 jurisdictions using a curated allowlist of official regulator domains to avoid misinformation.

3. Web Fetch: Deep Document Consumption with Citation Awareness

Web Fetch complements Web Search by fully ingesting URLs or PDF documents you provide, returning textual content or base64-encoded PDFs. This allows in-depth analysis of vendor contracts, legal notices, security briefs, or any document hosted online.

VENDOR_DOCS = [
    "https://vendor.example.com/trust",
    "https://vendor.example.com/legal/subprocessors",
    "https://vendor.example.com/security/soc2-scope.pdf",
    "https://vendor.example.com/legal/dpa.pdf",
]

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=8192,
    system=(
        "You are a third-party risk analyst for a healthcare system subject to "
        "HIPAA. Assess each vendor against: data residency, subprocessor "
        "disclosure, breach notification SLA, encryption at rest and in transit, "
        "BAA availability, and SOC 2 scope coverage. Cite the source for every "
        "finding."
    ),
    messages=[{"role": "user", "content": "Assess this vendor:\n" + "\n".join(VENDOR_DOCS)}],
    tools=[{
        "type": "web_fetch_20260318",
        "name": "web_fetch",
        "max_uses": 8,
        "allowed_domains": ["vendor.example.com"],
        "citations": {"enabled": True},
        "max_content_tokens": 60000,
    }],
)

The combination of Web Search and Web Fetch is especially powerful: search surfaces promising documents on a topic, fetch reads them, and Claude synthesizes findings with explicit citations. This approach trades breadth for depth and citation reliability.

4. MCP Connector: Native Integration with Enterprise Systems

The Model Context Protocol (MCP) connector in Foundry lets Claude call MCP-compliant APIs like Jira or ServiceNow directly—no need for client libraries or complex session management.

response = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "What's blocking the payments release?"}],
    mcp_servers=[{
        "type": "url",
        "url": "https://mcp.contoso.com/jira/sse",
        "name": "jira",
        "authorization_token": jira_oauth_token,
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "jira"}],
    betas=["mcp-client-2025-11-20"],
)

For IT support desks, this enables agents to combine directory lookups, compliance checks, and knowledge base queries—all governed by strict tool access control to prevent destructive commands.

5. Tool Search: Intelligent Routing at Scale

When an agent must manage hundreds of tools, typical selection breaks down due to confusion or overload.

Foundry’s Tool Search capability lets Claude dynamically select the right tool via natural language queries or regex patterns, with deferred loading of seldom-used tools to keep prompt size manageable.

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Open a Sev-2 for the checkout latency spike and page the on-call."}],
    tools=[
        {"type": "tool_search_tool_regex_20251119", "name": "tool_search_tool_regex"},
        # Frequently used hot tools
        {"name": "search_incidents", "description": "...", "input_schema": {...}},
        # Other tools deferred loading to preserve context size
        {"name": "create_incident", "description": "...", "input_schema": {...}, "defer_loading": True},
        {"name": "page_oncall", "description": "...", "input_schema": {...}, "defer_loading": True},
        # ... and hundreds more
    ],
)

This approach maintains precision and scalability, ensuring Claude-driven agents can function reliably even with vast tool ecosystems.

Quick Tips & Tricks

1. Host Claude Models on Azure to Guarantee Data Residency
   Choose Hosted on Azure deployments to keep inference and prompts within your Azure tenant, essential for regulated industries requiring data sovereignty.

2. Use JSON Schema for Output Formats to Avoid Manual Parsing
   Replace fragile post-processing with output_config.format schemas to enforce valid JSON and simplify downstream integration.

3. Enable Citations on Web Fetch for Compliance and Transparency
   Turn on citations.enabled to attach every insight to a source document, critical for audit trails in risk assessments or compliance monitoring.

4. Restrict Web Search Domains Using Allowlists
   Use allowed_domains to tightly control information sources during critical tasks like regulatory monitoring, blocking unauthorized sites by design.

5. Set Tool Configurations for Least Privilege in MCP Connectors
   Configure default_config and per-tool enabled flags to safely expose only read-only or non-destructive APIs to agents.

6. Defer Loading Large Toolsets for Efficient Prompt Usage
   Use defer_loading: true to avoid bloating context with seldom-used tools, leveraging Tool Search for dynamic selection instead.

Conclusion

Microsoft Foundry’s integration of Structured Outputs, Web Search, Web Fetch, MCP Connector, and Tool Search for Claude models hosted natively on Azure represents a major leap forward for deploying production-grade AI agents. By eliminating repetitive engineering overhead, enforcing data integrity, and seamlessly connecting to enterprise systems, Foundry empowers developers to focus on building differentiated AI experiences.

This paradigm shift reconciles the need for agility and compliance, letting regulated industries confidently adopt frontier AI capabilities. As the platform evolves, expect greater sophistication in tool orchestration, observability, and security features, making agentic AI a foundational enterprise technology.

References

1. From single call to agents: five new Claude capabilities now available in Microsoft Foundry — The original Microsoft Foundry Blog post detailing these capabilities.
2. Claude Platform Docs - Structured Outputs — Official documentation on Claude’s structured output features.
3. Claude Platform Docs - Web Search Tool — Details on web search integration and usage.
4. Claude Platform Docs - MCP Connector — Reference for Model Context Protocol server integration.
5. Microsoft Foundry Documentation — Microsoft’s official Foundry platform documentation and related resources.