Framework Integrations

June 4, 2026 · View on GitHub

DNS-AID works with every major AI agent framework — via MCP (zero new code) or the Python library (3 lines).

Key insight: Because DNS-AID ships an MCP server, any framework with MCP support gains DNS-based agent discovery automatically. No DNS libraries. No new dependencies in your agent code. Just configure a transport and go.

┌──────────────────────────────────────────────────────────┐
│              AI Agent Frameworks                         │
│  LangChain · CrewAI · AutoGen · ADK · OpenAI Agents     │
│  Semantic Kernel · Claude Desktop · n8n · Tines          │
└────────────────────┬─────────────────────────────────────┘
                     │  MCP protocol (stdio or HTTP)
                     ▼
          ┌─────────────────────┐
          │  DNS-AID MCP Server │
          │                     │
          │  discover_agents    │
          │  publish_agent      │
          │  verify_agent       │
          └──────────┬──────────┘
                     │
                     ▼
              ┌─────────────┐
              │     DNS     │
              │  SVCB + TXT │
              │   DNSSEC    │
              └─────────────┘

How It Works

The DNS-AID MCP server exposes tools that any MCP client can call:

MCP Tool	What It Does
`discover_agents_via_dns`	Query DNS for agents at a domain
`publish_agent_to_dns`	Publish an agent's endpoint to DNS
`verify_agent_dns`	Validate DNSSEC and DANE for an agent

Two transport modes are supported:

stdio — Local process, launched by the framework. Best for development and single-machine deployments.
HTTP — Remote server. Best for shared infrastructure and cloud deployments.

Every framework example below uses stdio transport. To switch to HTTP, replace the command/args with a URL pointing to your deployed DNS-AID MCP server.

MCP-Native Frameworks (Zero Code)

These frameworks have built-in MCP support. You configure DNS-AID as a server — no DNS-AID imports needed in your agent code.

LangChain

~122k stars — the most widely adopted LLM framework.

Uses langchain-mcp-adapters to bridge MCP tools into LangChain agents.

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_anthropic import ChatAnthropic

client = MultiServerMCPClient({
    "dns-aid": {
        "transport": "stdio",
        "command": "python",
        "args": ["-m", "dns_aid.mcp.server"],
    }
})
tools = await client.get_tools()
model = ChatAnthropic(model="claude-sonnet-4-20250514").bind_tools(tools)
response = await model.ainvoke("Find booking agents at example.com")

CrewAI

~42k stars — multi-agent orchestration with role-based agents.

Uses MCPServerAdapter to wrap any MCP server as CrewAI tools.

from crewai import Agent, Task, Crew
from crewai_tools import MCPServerAdapter
from mcp import StdioServerParameters

server_params = StdioServerParameters(
    command="python", args=["-m", "dns_aid.mcp.server"]
)
with MCPServerAdapter(server_params) as tools:
    agent = Agent(
        role="Agent Discovery Specialist",
        goal="Find AI agents via DNS-AID",
        tools=tools,
    )
    task = Task(
        description="Discover all MCP agents at example.com",
        agent=agent,
    )
    Crew(agents=[agent], tasks=[task]).kickoff()

Microsoft AutoGen

~53k stars — multi-agent conversation framework.

Uses autogen-ext[mcp] to expose MCP tools to AutoGen agents.

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

server = StdioServerParams(command="python", args=["-m", "dns_aid.mcp.server"])
tools = await mcp_server_tools(server)
agent = AssistantAgent(
    name="discovery_agent",
    model_client=OpenAIChatCompletionClient(model="gpt-4o"),
    tools=tools,
)
result = await agent.run(task="Discover agents at example.com")

Google ADK

~9k stars — Google's Agent Development Kit.

Uses McpToolset with stdio connection parameters.

from google.adk.agents import Agent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
from mcp import StdioServerParameters

root_agent = Agent(
    model="gemini-2.5-pro",
    name="discovery_agent",
    instruction="Discover AI agents via DNS using DNS-AID",
    tools=[
        McpToolset(
            connection_params=StdioConnectionParams(
                server_params=StdioServerParameters(
                    command="python",
                    args=["-m", "dns_aid.mcp.server"],
                ),
                timeout=30,
            )
        )
    ],
)

OpenAI Agents SDK

Uses MCPServerStdio to connect MCP servers as agent tools.

from agents import Agent
from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    params={"command": "python", "args": ["-m", "dns_aid.mcp.server"]}
) as server:
    agent = Agent(
        name="discovery_agent",
        instructions="Discover AI agents via DNS",
        mcp_servers=[server],
    )

Semantic Kernel (Microsoft)

~22k stars — Microsoft's AI orchestration SDK.

Uses MCP plugin support to register DNS-AID as a kernel plugin.

from semantic_kernel import Kernel
from semantic_kernel.connectors.mcp import MCPStdioPlugin

kernel = Kernel()
plugin = MCPStdioPlugin(command="python", args=["-m", "dns_aid.mcp.server"])
kernel.add_plugin(plugin, "dns_aid")

Workflow & Automation Platforms

These platforms integrate via configuration rather than code.

Claude Desktop

Add to your Claude Desktop MCP configuration (claude_desktop_config.json):

{
  "mcpServers": {
    "dns-aid": {
      "command": "python",
      "args": ["-m", "dns_aid.mcp.server"]
    }
  }
}

Once configured, Claude can call discover_agents_via_dns and publish_agent_to_dns directly in conversation.

n8n

~55k stars — workflow automation platform with MCP node support.

Configure an MCP node pointing at the DNS-AID server:

Transport: stdio
Command: python
Args: -m dns_aid.mcp.server

Then wire the discover_agents_via_dns tool output into downstream workflow nodes (e.g., HTTP requests to discovered endpoints).

Tines

SOAR platform with MCP support. Ideal for security verification workflows:

Configure DNS-AID MCP server as an MCP action
Use verify_agent_dns to validate DNSSEC for discovered agents
Feed results into incident response or compliance workflows

Python Library (Any Framework)

For frameworks without MCP support — or when you want direct programmatic access — use the DNS-AID library:

from dns_aid.core.discoverer import discover

result = await discover("example.com", protocol="mcp")
for agent in result.agents:
    print(f"{agent.name}: {agent.endpoint_url}")

Three lines. No MCP server process needed.

This works with any Python framework or application:

LlamaIndex (~46k stars) — data-aware agent framework
Haystack — production-ready NLP pipelines
Camel-AI — multi-agent communication framework
Any custom Python application

Publishing an Agent

from dns_aid.core.publisher import publish

await publish(
    name="network-specialist",
    domain="example.com",
    protocol="mcp",
    endpoint="mcp.example.com",
)

Verifying DNSSEC

from dns_aid.core.validator import verify

result = await verify("network-specialist.example.com")
print(f"DNSSEC valid: {result.dnssec_valid}")
print(f"Security rating: {result.security_rating}")

AWS Integration

Amazon Bedrock Agents

Deploy DNS-AID as a Lambda action group that Bedrock agents can invoke:

Package DNS-AID as a Lambda function
Define an action group with discover and publish actions
Bedrock agents call the action group to discover other agents via DNS

AWS Multi-Agent Orchestrator

Use DNS-AID to dynamically populate the agent registry:

from dns_aid.core.discoverer import discover

# At orchestrator startup, discover available agents
result = await discover("example.com", protocol="a2a")
for agent in result.agents:
    orchestrator.register_agent(
        name=agent.name,
        endpoint=agent.endpoint_url,
    )

Summary

Framework	Stars	MCP Native	Integration Method	Lines of Code
LangChain	122k	Yes	`MultiServerMCPClient`	8
Dify	60k	Yes	MCP config	0 (config)
n8n	55k	Yes	MCP node	0 (config)
AutoGen	53k	Yes	`mcp_server_tools()`	6
LlamaIndex	46k	No	Python library	3
CrewAI	42k	Yes	`MCPServerAdapter`	10
Semantic Kernel	22k	Yes	`MCPStdioPlugin`	4
Google ADK	9k	Yes	`McpToolset`	12
OpenAI Agents	—	Yes	`MCPServerStdio`	6
Claude Desktop	—	Yes	JSON config	0 (config)

8 out of 10 frameworks require zero DNS-AID code — just MCP configuration. The remaining two need 3 lines of Python.

Next Steps

Getting Started — Install DNS-AID and run your first discovery
Architecture — How DNS-AID resolves agent metadata
API Reference — Full library and MCP tool documentation