https://community.databricks.com/t5/technical-blog/how-to-deploy-agent-to-agent-a2a-protocol-on-databricks-apps-gt/ba-p/134213 <P><SPAN>Modern AI systems rarely live alone. They collaborate. Google’s </SPAN><STRONG>Agent-to-Agent (A2A)</STRONG><SPAN> protocol gives agents a common language (JSON-RPC over HTTP/S, with streaming via SSE) plus a discovery mechanism (the </SPAN><STRONG>Agent Card</STRONG><SPAN>) so they can find and work with each other securely.&nbsp;</SPAN></P> <P><STRONG>Databricks Apps</STRONG><SPAN> let you ship secure, serverless AI apps </SPAN><I><SPAN>inside</SPAN></I><SPAN> your Databricks workspace—no extra infra, integrated with Unity Catalog, SQL, Model Serving, OAuth and more. That’s perfect territory for hosting interoperable A2A agents where data governance and latency matter.&nbsp;</SPAN></P> <P><SPAN>In this post, you’ll deploy a production-style A2A server as a Databricks App. The example agent (“</SPAN><STRONG>CurrencyAgent</STRONG><SPAN>”) uses </SPAN><STRONG>LangGraph</STRONG><SPAN> tools + a Databricks</SPAN><SPAN>&nbsp;LLM endpoint to answer FX questions—then exposes itself as an A2A service with streaming updates and optional push notifications.</SPAN></P> <H2><SPAN>What you’ll build</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><SPAN>A LangGraph-powered agent with a simple tool (get_exchange_rate via the Frankfurter API). </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>An </SPAN><STRONG>A2A Server</STRONG><SPAN> (Starlette/ASGI) that publishes an </SPAN><STRONG>Agent Card</STRONG><SPAN> and implements streaming (message/stream) and task artifacts. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>A </SPAN><STRONG>Databricks App</STRONG><SPAN> (serverless) with a clean app.yaml, OAuth-friendly /api routing, and secrets handled safely.</SPAN><SPAN><BR /></SPAN></LI> </UL> <H2><SPAN>Architecture (at a glance)</SPAN></H2> <P><span class="lia-inline-image-display-wrapper lia-image-align-inline" image-alt="Mahavir_Teraiya_0-1759929370525.png" style="width: 999px;"><img src="https://community.databricks.com/t5/image/serverpage/image-id/20568i78DDF6902337E56E/image-size/large?v=v2&amp;px=999" role="button" title="Mahavir_Teraiya_0-1759929370525.png" alt="Mahavir_Teraiya_0-1759929370525.png" /></span></P> <H3><SPAN>Why A2A + Databricks Apps?</SPAN></H3> <P><SPAN>A2A standardizes inter-agent comms (HTTP + JSON-RPC + SSE) and discovery (Agent Card). Databricks Apps provide governed hosting, OAuth integration and serverless scale so you can safely place agents next to your data and models.&nbsp;</SPAN></P> <H2><SPAN>Prerequisites</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><SPAN>A Databricks workspace with </SPAN><STRONG>Apps</STRONG><SPAN> enabled and permission to deploy apps. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>A </SPAN><STRONG>Model Serving</STRONG><SPAN> endpoint (e.g., Foundation Models API or your own) accessible via the</SPAN><SPAN>&nbsp;interface. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>(Recommended) OAuth setup for the app’s service principal and/or secrets configured via </SPAN><STRONG>Databricks Secrets</STRONG><SPAN>—don’t hardcode tokens. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Basic familiarity with the </SPAN><STRONG>Apps Cookbook</STRONG><SPAN> (FastAPI/ASGI patterns, /api route requirements, and deployment flow).</SPAN><SPAN><BR /></SPAN></LI> </UL> <H2><SPAN>Project layout</SPAN></H2> <LI-CODE lang="markup">app/ agent.py # LangGraph agent using Databricks-hosted LLM agent_executor.py # A2A AgentExecutor wiring (streaming + artifacts) server.py # Starlette app exposing A2A endpoints + Agent Card test.py # Notebook/REPL client using A2A SDK app.yaml # Databricks App config (command + env) requirements.txt # a2a-sdk[http-server], langgraph, httpx, uvicorn, etc.</LI-CODE> <P><SPAN>The </SPAN><STRONG>A2A SDK</STRONG><SPAN> (a2a-sdk) provides server/client primitives, Agent Card types, event queues, push notifications, and JSON-RPC methods.&nbsp;</SPAN></P> <P>&nbsp;</P> <H1><STRONG>Step 1 — Implement the agent (LangGraph + ChatDatabricks)</STRONG></H1> <P class="p3"><SPAN class="s2"><STRONG>Goal:</STRONG></SPAN> Build a small ReAct agent that calls a currency API tool and returns a <SPAN class="s2"><STRONG>stable, typed</STRONG></SPAN> (Pydantic) response you can safely consume downstream.</P> <P class="p4"><STRONG>Key points:</STRONG></P> <UL> <LI> <P class="p1">Use <SPAN class="s1"><STRONG>ChatDatabricks</STRONG></SPAN> (LangChain on Databricks) and point it at your <SPAN class="s1"><STRONG>Model Serving endpoint</STRONG></SPAN> by name.</P> </LI> <LI> <P class="p1"><SPAN class="s1">Bind your tools and enable </SPAN><SPAN class="s2"><STRONG>structured output</STRONG></SPAN><SPAN class="s1"> with </SPAN>response_format=(..., ResponseFormat)<SPAN class="s1">.</SPAN></P> </LI> <LI> <P class="p1"><SPAN class="s1">Read the validated object from </SPAN>state.values["structured_response"]<SPAN class="s1">.</SPAN></P> </LI> <LI> <P class="p1"><SPAN class="s1"><STRONG>Auth:</STRONG></SPAN><SPAN class="s2"> set </SPAN><SPAN class="s1"><STRONG>either</STRONG></SPAN><SPAN class="s2"> PAT (</SPAN>DATABRICKS_TOKEN<SPAN class="s2">) </SPAN><SPAN class="s1"><STRONG>or</STRONG></SPAN><SPAN class="s2"> OAuth (</SPAN>DATABRICKS_CLIENT_ID<SPAN class="s2"> + </SPAN>DATABRICKS_CLIENT_SECRET<SPAN class="s2">) — not both.</SPAN></P> <P class="p2">(Optional helper below auto-picks one if both are present.)</P> </LI> <LI> <P class="p1">Frankfurter is a free, open-source currency API tracking ECB reference rates.</P> </LI> </UL> <LI-CODE lang="python"># app/agent.py (excerpt) import os, httpx, json, logging from typing import Literal from pydantic import BaseModel from langchain_core.tools import tool from langgraph.prebuilt import create_react_agent from databricks_langchain import ChatDatabricks log = logging.getLogger(__name__) # --- Tool -------------------------------------------------------------------- @tool def get_exchange_rate(currency_from: str="USD", currency_to: str="EUR", currency_date: str="latest"): """Use this to get current exchange rate.""" r = httpx.get( f"https://api.frankfurter.app/{currency_date}", params={"from": currency_from, "to": currency_to}, timeout=15.0, ) r.raise_for_status() data = r.json() if "rates" not in data: return {"error": "Invalid API response format."} return data # --- Structured response schema ---------------------------------------------- class ResponseFormat(BaseModel): status: Literal["input_required", "completed", "error"] = "input_required" message: str # --- Optional: guard against PAT+OAuth at once (pick one) -------------------- def _prefer_single_databricks_auth(): pat = bool(os.getenv("DATABRICKS_TOKEN")) oauth = bool(os.getenv("DATABRICKS_CLIENT_ID") and os.getenv("DATABRICKS_CLIENT_SECRET")) if pat and oauth: prefer = (os.getenv("DBX_AUTH_PREFERENCE") or "pat").lower() if prefer == "oauth": os.environ.pop("DATABRICKS_TOKEN", None) log.warning("Both PAT and OAuth found; preferring OAuth (unset DATABRICKS_TOKEN).") else: os.environ.pop("DATABRICKS_CLIENT_ID", None) os.environ.pop("DATABRICKS_CLIENT_SECRET", None) log.warning("Both PAT and OAuth found; preferring PAT (unset CLIENT_ID/SECRET).") # --- LLM factory -------------------------------------------------------------- def _build_dbx_llm() -&gt; ChatDatabricks: _prefer_single_databricks_auth() # harmless if only one method is set endpoint = os.getenv("DBX_LLM_ENDPOINT") # e.g., "databricks-dbrx-instruct" or your custom endpoint if not endpoint: raise RuntimeError("Missing required env var: DBX_LLM_ENDPOINT") # ChatDatabricks uses your Databricks workspace auth (PAT or OAuth). # When running outside a workspace, also set DATABRICKS_HOST. return ChatDatabricks( endpoint=endpoint, temperature=0.0, max_tokens=256, # Optional: smoothes tool-calling streams for some models disable_streaming="tool_calling", ) # --- Agent ------------------------------------------------------------------- class CurrencyAgent: SYSTEM_INSTRUCTION = ( "You are a specialized assistant for currency conversions. " "Use the 'get_exchange_rate' tool to answer currency exchange questions. " "If asked about anything else, politely refuse." ) def __init__(self): llm = _build_dbx_llm() tools = [get_exchange_rate] self.graph = create_react_agent( llm.bind_tools(tools), tools=tools, prompt=self.SYSTEM_INSTRUCTION, response_format=( "Set status to input_required, completed, or error as appropriate.", ResponseFormat, ), )</LI-CODE> <P><SPAN>Frankfurter is a free, open-source currency API tracking ECB reference rates.&nbsp;</SPAN></P> <P><SPAN>LangGraph supports </SPAN><STRONG>structured responses</STRONG><SPAN> via response_format, which you read from state.values["structured_response"].&nbsp;</SPAN></P> <P><SPAN>Databricks </SPAN><STRONG>Model Serving</STRONG><SPAN> exposes a unified</SPAN><SPAN>&nbsp;API, which lets you use standard Chat clients in this case ChatDatabricks.&nbsp;</SPAN></P> <H2><SPAN>Step 2 — Wire the agent to the A2A runtime</SPAN></H2> <P><SPAN>app/agent_executor.py bridges A2A’s </SPAN><STRONG>JSON-RPC</STRONG><SPAN> calls to your agent:</SPAN></P> <UL> <LI style="font-weight: 400;" aria-level="1"><SPAN>Accept a message, create/update a </SPAN><STRONG>Task</STRONG><SPAN>, stream </SPAN><STRONG>status</STRONG><SPAN> (working / input_required), and emit a final </SPAN><STRONG>artifact</STRONG><SPAN>.</SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>A2A uses an event queue to buffer updates for streaming via </SPAN><STRONG>SSE</STRONG><SPAN>.</SPAN><SPAN><BR /></SPAN></LI> </UL> <LI-CODE lang="python"># app/agent_executor.py (excerpt) from a2a.server.agent_execution import AgentExecutor, RequestContext from a2a.server.events import EventQueue from a2a.server.tasks import TaskUpdater from a2a.types import TaskState, Part, TextPart from a2a.utils import new_agent_text_message, new_task from app.agent import CurrencyAgent class CurrencyAgentExecutor(AgentExecutor): def __init__(self): self.agent = CurrencyAgent() async def execute(self, context: RequestContext, event_queue: EventQueue) -&gt; None: query = context.get_user_input() task = context.current_task or new_task(context.message) await event_queue.enqueue_event(task) updater = TaskUpdater(event_queue, task.id, task.context_id) async for item in self.agent.stream(query, task.context_id): if item["require_user_input"]: await updater.update_status( TaskState.input_required, new_agent_text_message(item["content"], task.context_id, task.id), final=True, ) break elif not item["is_task_complete"]: await updater.update_status( TaskState.working, new_agent_text_message(item["content"], task.context_id, task.id), ) else: await updater.add_artifact([Part(root=TextPart(text=item["content"]))], name="conversion_result") await updater.complete() break</LI-CODE> <P><SPAN>In A2A, streaming is done with SSE; clients receive a sequence of JSON-RPC responses until the task completes.&nbsp;</SPAN></P> <H2><SPAN>Step 3 — Expose an Agent Card + JSON-RPC endpoints (Starlette)</SPAN></H2> <P><SPAN>Publish capabilities and skills so other agents can discover and call yours:</SPAN></P> <LI-CODE lang="python"># app/server.py (excerpt) import httpx, logging from a2a.server.apps import A2AStarletteApplication from a2a.server.request_handlers import DefaultRequestHandler from a2a.server.tasks import InMemoryTaskStore, InMemoryPushNotificationConfigStore, BasePushNotificationSender from a2a.types import AgentCapabilities, AgentCard, AgentSkill from app.agent import CurrencyAgent from app.agent_executor import CurrencyAgentExecutor def build_asgi_app(): capabilities = AgentCapabilities(streaming=True, push_notifications=True) skill = AgentSkill( id="convert_currency", name="Currency Exchange Rates Tool", description="Helps with exchange values between various currencies", tags=["currency conversion", "currency exchange"], examples=["What is exchange rate between USD and GBP?"], ) agent_card = AgentCard( name="Currency Agent", description="Helps with exchange rates for currencies", url="/", # important in Databricks Apps: relative path behind reverse proxy version="1.0.0", default_input_modes=CurrencyAgent.SUPPORTED_CONTENT_TYPES, default_output_modes=CurrencyAgent.SUPPORTED_CONTENT_TYPES, capabilities=capabilities, skills=[skill], ) httpx_client = httpx.AsyncClient() push_store = InMemoryPushNotificationConfigStore() push_sender = BasePushNotificationSender(httpx_client=httpx_client, config_store=push_store) request_handler = DefaultRequestHandler( agent_executor=CurrencyAgentExecutor(), task_store=InMemoryTaskStore(), push_config_store=push_store, push_sender=push_sender, ) server = A2AStarletteApplication(agent_card=agent_card, http_handler=request_handler) app = server.build() async def _close_httpx(): await httpx_client.aclose() app.add_event_handler("shutdown", _close_httpx) return app app = build_asgi_app()</LI-CODE> <P><SPAN>The </SPAN><STRONG>Agent Card</STRONG><SPAN> advertises identity, capabilities (e.g., streaming, pushNotifications), skills, and how to authenticate. Clients usually fetch it from a well-known path under your base URL.&nbsp;</SPAN></P> <H2><SPAN>Step 4 — Package as a Databricks App</SPAN></H2> <P><SPAN>Create app.yaml to define how your server starts and how env vars flow in. </SPAN><STRONG>Never</STRONG><SPAN> hardcode secrets—use </SPAN><STRONG>App resources</STRONG><SPAN> + valueFrom or Databricks Secrets so Databricks injects them as environment variables at runtime.</SPAN></P> <LI-CODE lang="python"># app.yaml command: ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"] env: # Workspace URL &amp; endpoint name can be plain values (non-secret). - name: DATABRICKS_WORKSPACE_URL value: "https://&lt;your-workspace&gt;.cloud.databricks.com" - name: DBX_LLM_ENDPOINT value: "&lt;your-serving-endpoint&gt;" # Token is secret: reference an App resource key you configured in the UI. # For production, prefer OAuth with the app’s service principal. - name: DATABRICKS_TOKEN valueFrom: dbx_llm_token # &lt;-- this key is defined in App resources (Secret)</LI-CODE> <P><STRONG>Notes</STRONG></P> <UL> <LI style="font-weight: 400;" aria-level="1"><SPAN>Databricks Apps require </SPAN><STRONG>OAuth Bearer</STRONG><SPAN> auth on routes under /api for token-protected endpoints. If you expose any API routes for external clients, mount them under /api/*. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>You can add secrets/resources in the </SPAN><STRONG>Apps UI</STRONG><SPAN> and then map them into env via valueFrom. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>For </SPAN><STRONG>Foundation Models</STRONG><SPAN> or </SPAN><STRONG>route-optimized Serving</STRONG><SPAN> endpoints, use </SPAN><STRONG>OAuth tokens</STRONG><SPAN> (service principal) rather than PATs. </SPAN><SPAN><BR /><BR /></SPAN></LI> </UL> <H2><SPAN>Step 5 — Install dependencies</SPAN></H2> <P><SPAN>Your requirements.txt should include:</SPAN></P> <LI-CODE lang="python">uvicorn fastapi httpx langgraph databricks_langchain a2a-sdk[http-server]&gt;=0.3.0</LI-CODE> <P><SPAN>The official </SPAN><STRONG>A2A SDK</STRONG><SPAN> is published on PyPI as a2a-sdk (extras: [http-server], [grpc], [telemetry]).&nbsp;</SPAN></P> <H2><SPAN>Step 6 — Deploy &amp; run on Databricks Apps</SPAN></H2> <OL> <LI style="font-weight: 400;" aria-level="1"><STRONG>Create App</STRONG><SPAN> → </SPAN><I><SPAN>Custom</SPAN></I><SPAN> → point to your repo (or Git folder).</SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Add an </SPAN><STRONG>App resource</STRONG><SPAN> for your secret (e.g., dbx_llm_token) and grant least-privilege access. Map it to DATABRICKS_TOKEN via valueFrom in app.yaml. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Click </SPAN><STRONG>Deploy</STRONG><SPAN>; the platform starts your app with the uvicorn command you specified. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Open the app URL; the </SPAN><STRONG>Agent Card</STRONG><SPAN> will be served at the well-known path the SDK exposes (or at / depending on your framework wiring).</SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>(Optional) Validate the /api routes with a Bearer token as described in the cookbook.</SPAN><SPAN><BR /></SPAN></LI> </OL> <P><SPAN>Databricks Apps run behind a reverse proxy with platform-managed networking—avoid assumptions about request origin and keep your base URLs </SPAN><STRONG>relative</STRONG><SPAN>.&nbsp;</SPAN></P> <H2><SPAN>Step 7 — Test the agent with the A2A client (from a notebook or local)</SPAN></H2> <LI-CODE lang="python"># test.py (excerpt): call your app via A2A client import json, logging, httpx from uuid import uuid4 from a2a.client import A2ACardResolver, A2AClient from a2a.types import MessageSendParams, SendMessageRequest BASE_URL = "https://&lt;your-app-url&gt;" async def chat_once(text: str): async with httpx.AsyncClient(timeout=60.0) as httpx_client: resolver = A2ACardResolver(httpx_client=httpx_client, base_url=BASE_URL) card = await resolver.get_agent_card() client = A2AClient(httpx_client=httpx_client, agent_card=card) req = SendMessageRequest(id=str(uuid4()), params=MessageSendParams(message={"role":"user", "parts":[{"kind":"text","text":text}]})) resp = await client.send_message(req) print(json.dumps(resp.model_dump(mode="json"), indent=2)) # e.g. # await chat_once("USD to EUR today?")</LI-CODE> <P><SPAN>The SDK exposes both non-streaming and streaming calls, plus push-notification configuration APIs.&nbsp;</SPAN></P> <H2><SPAN>Security, auth, and secrets (read this!)</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><STRONG>Never</STRONG><SPAN> commit tokens to source control. Use </SPAN><STRONG>App secrets/resources</STRONG><SPAN> to inject env vars at runtime; map them via valueFrom in app.yaml. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Prefer </SPAN><STRONG>OAuth</STRONG><SPAN> (service principal) for production access to Model Serving, especially on </SPAN><STRONG>route-optimized</STRONG><SPAN> or FM endpoints. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><SPAN>Databricks Apps use </SPAN><STRONG>OAuth2</STRONG><SPAN> for user access; secure machine-to-machine calls to your app should target /api/* and send a Bearer token. </SPAN><SPAN><BR /><BR /></SPAN></LI> </UL> <H2><SPAN>Troubleshooting</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><STRONG>401/403 from Model Serving</STRONG><STRONG><BR /></STRONG><STRONG><BR /></STRONG><SPAN> Check the token type (PAT vs OAuth) and the app service principal’s permissions (CAN QUERY on the serving endpoint). Route-optimized endpoints require OAuth. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Your /api endpoints work locally but 401 in the app</STRONG><STRONG><BR /></STRONG><STRONG><BR /></STRONG><SPAN> Databricks Apps enforce Bearer auth on /api/*. Generate a workspace OAuth token (CLI) and include it in the Authorization: Bearer &lt;token&gt; header. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Agent discovery fails</STRONG><STRONG><BR /></STRONG><STRONG><BR /></STRONG><SPAN> Verify the Agent Card URL served by your app (well-known path) and ensure the url in the card uses a </SPAN><STRONG>relative</STRONG><SPAN> base when running behind the Databricks proxy. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Streaming isn’t streaming</STRONG><STRONG><BR /></STRONG><STRONG><BR /></STRONG><SPAN> Confirm you’re calling the </SPAN><STRONG>streaming</STRONG><SPAN> method and the server responds with Content-Type: text/event-stream as specified by A2A’s SSE flow. </SPAN><SPAN><BR /><BR /></SPAN></LI> </UL> <H2><SPAN>Going deeper</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><STRONG>Push notifications</STRONG><SPAN>: Configure webhooks via the SDK when clients can’t hold SSE streams (mobile, serverless). Use the SDK’s set_task_callback / get_task_callback methods. </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>More frameworks</STRONG><SPAN>: Databricks Apps support Streamlit, Dash, Flask, </SPAN><STRONG>FastAPI</STRONG><SPAN>, and more—see the Apps Cookbook for recipes (auth, Lakehouse access, CI/CD). </SPAN><SPAN><BR /><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Agent design</STRONG><SPAN>: LangGraph response_format + Pydantic models keep outputs predictable when multiple agents collaborate downstream.</SPAN><SPAN><BR /></SPAN></LI> </UL> <H2><SPAN>Appendix — Minimal </SPAN><A href="http://server.py" target="_blank" rel="noopener"><SPAN>server.py</SPAN></A><SPAN> + app.yaml templates</SPAN></H2> <LI-CODE lang="python"># server.py (minimal) from a2a.server.apps import A2AStarletteApplication from a2a.server.request_handlers import DefaultRequestHandler from a2a.server.tasks import InMemoryTaskStore, InMemoryPushNotificationConfigStore, BasePushNotificationSender from a2a.types import AgentCapabilities, AgentCard import httpx from app.agent_executor import CurrencyAgentExecutor from app.agent import CurrencyAgent def build_asgi_app(): card = AgentCard( name="Currency Agent", description="Exchange rates over A2A", url="/", version="1.0.0", capabilities=AgentCapabilities(streaming=True, push_notifications=True), default_input_modes=CurrencyAgent.SUPPORTED_CONTENT_TYPES, default_output_modes=CurrencyAgent.SUPPORTED_CONTENT_TYPES, ) httpx_client = httpx.AsyncClient() request_handler = DefaultRequestHandler( agent_executor=CurrencyAgentExecutor(), task_store=InMemoryTaskStore(), push_config_store=InMemoryPushNotificationConfigStore(), push_sender=BasePushNotificationSender(httpx_client=httpx_client), ) return A2AStarletteApplication(agent_card=card, http_handler=request_handler).build() app = build_asgi_app() # app.yaml (minimal, secrets via valueFrom) command: ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"] env: - name: DATABRICKS_WORKSPACE_URL value: "https://&lt;your-workspace&gt;.cloud.databricks.com" - name: DBX_LLM_ENDPOINT value: "&lt;your-serving-endpoint&gt;" - name: DATABRICKS_TOKEN valueFrom: dbx_llm_token</LI-CODE> <H2><SPAN>References</SPAN></H2> <UL> <LI style="font-weight: 400;" aria-level="1"><STRONG>A2A overview &amp; principles</STRONG><SPAN> (Google Developers Blog) — open protocol for agent interoperability.</SPAN><SPAN><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>A2A spec &amp; SDK</STRONG><SPAN> — JSON-RPC + SSE streaming, Python SDK, push config APIs.</SPAN><SPAN><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Databricks Apps</STRONG><SPAN> — serverless hosting, platform integration, OAuth model, best practices.</SPAN><SPAN><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Model Serving</STRONG><SPAN> — unified API for FMs and custom endpoints.</SPAN><SPAN><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Apps Cookbook</STRONG><SPAN> — FastAPI /api auth, local/external connections, deployment steps.</SPAN><SPAN><BR /></SPAN></LI> <LI style="font-weight: 400;" aria-level="1"><STRONG>Frankfurter API</STRONG><SPAN> — free ECB reference rates for examples.</SPAN><SPAN><BR /></SPAN></LI> </UL> <H2><SPAN>Wrap-up</SPAN></H2> <P><SPAN>With A2A providing the interoperability fabric and Databricks Apps providing a secure, serverless runtime next to your governed data and models, you can </SPAN><STRONG>stand up enterprise-ready agents quickly</STRONG><SPAN>—and </SPAN><I><SPAN>connect</SPAN></I><SPAN> them to the rest of your agent ecosystem when you’re ready. Swap the currency tool for your business tools, wire in push notifications, and you’ve got a production pattern you can reuse across many agents.</SPAN></P> Tue, 21 Oct 2025 11:45:43 GMT Mahavir_Teraiya 2025-10-21T11:45:43Z https://community.databricks.com/t5/technical-blog/how-to-deploy-agent-to-agent-a2a-protocol-on-databricks-apps-gt/ba-p/134213 <P><SPAN>Modern AI systems rarely live alone. They collaborate. Google’s </SPAN><STRONG>Agent-to-Agent (A2A)</STRONG><SPAN> protocol gives agents a common language (JSON-RPC over HTTP/S, with streaming via SSE) plus a discovery mechanism (the </SPAN><STRONG>Agent Card</STRONG><SPAN>) so they can find and work with each other securely.&nbsp;</SPAN></P> <P><STRONG>Databricks Apps</STRONG><SPAN> let you ship secure, serverless AI apps </SPAN><I><SPAN>inside</SPAN></I><SPAN> your Databricks workspace—no extra infra, integrated with Unity Catalog, SQL, Model Serving, OAuth and more. That’s perfect territory for hosting interoperable A2A agents where data governance and latency matter.&nbsp;</SPAN></P> <P><SPAN>In this post, you’ll deploy a production-style A2A server as a Databricks App. The example agent (“</SPAN><STRONG>CurrencyAgent</STRONG><SPAN>”) uses </SPAN><STRONG>LangGraph</STRONG><SPAN> tools + a Databricks</SPAN><SPAN>&nbsp;LLM endpoint to answer FX questions—then exposes itself as an A2A service with streaming updates and optional push notifications. </SPAN></P> Tue, 21 Oct 2025 11:45:43 GMT https://community.databricks.com/t5/technical-blog/how-to-deploy-agent-to-agent-a2a-protocol-on-databricks-apps-gt/ba-p/134213 Mahavir_Teraiya 2025-10-21T11:45:43Z https://community.databricks.com/t5/technical-blog/how-to-deploy-agent-to-agent-a2a-protocol-on-databricks-apps-gt/bc-p/139715#M836 <P><STRONG>Subject: 302 Authentication Errors on Agent Discovery Endpoint</STRONG></P><P>Hi, thanks for the great tutorial! I successfully deployed the A2A Currency Agent on <STRONG>Azure Databricks Apps, but I'm getting 302 redirects when trying to test it programmatically from a Databricks notebook.</STRONG></P><P><STRONG>Issue: All endpoints return 302 redirects requiring OAuth login:</STRONG></P><UL><LI>/.well-known/agent-card.json → 302 redirect</LI><LI>Even when using WorkspaceClient().config.authenticate() headers</LI><LI>Even when using service principal Bearer tokens</LI><LI>The agent card JSON is visible via browser when logged into Databricks, but I can't send messages programmatically<P><STRONG>Questions:</STRONG></P><UL><LI>Should the agent card be publicly accessible per A2A protocol?</LI><LI>How do you authenticate to A2A endpoints from Databricks notebooks?</LI><LI>The tutorial's test code (Step 7) doesn't show authentication - how is this supposed to work?<P>Any guidance on how to properly test the agent would be appreciated!</P></LI></UL></LI></UL> Wed, 19 Nov 2025 19:03:41 GMT https://community.databricks.com/t5/technical-blog/how-to-deploy-agent-to-agent-a2a-protocol-on-databricks-apps-gt/bc-p/139715#M836 159937 2025-11-19T19:03:41Z