DEV Community: mikerawsonnz

Dynamic Health Monitor: Auto-discovering Monitoring for Your Services

mikerawsonnz — Mon, 24 Aug 2026 06:10:07 +0000

Effortless Health Monitoring with Dynamic Health Monitor

As developers, we all know the pain of maintaining complex monitoring configurations. Services come and go, IPs change, and suddenly your carefully crafted dashboards are full of red, but the actual problem is a newly deployed microservice that wasn't added to the monitoring system. What if you could throw a single seed at a monitoring agent, and it intelligently discovered, monitored, and even understood the dependencies of your entire application stack, without you ever touching a config file again?

This is precisely the problem the Dynamic Health Monitor agent solves. Powered by gosce-health and accessible via the VDA platform, this agent takes the drudgery out of health monitoring. Give it a starting point – a domain name, a list of URLs, a docker-compose.yml file, or even a public GitHub repository – and it springs into action.

It automatically discovers every service within your defined scope, whether it's an HTTP endpoint, a TCP port, an SSL certificate, or a DNS record. More than just checking for uptime, it learns the latency baseline for each service, establishing a dynamic understanding of your application's normal behavior. Crucially, it doesn't just report individual failures; it intelligently rolls up dependent failures to identify a single root cause, saving you countless hours of debugging. And as your services appear, disappear, or change, the Dynamic Health Monitor adapts, making your monitoring truly evergreen.

How to Interact with Dynamic Health Monitor

You can interact with the Dynamic Health Monitor via its MCP endpoint using streamable HTTP, or through A2A (Agent-to-Agent) messaging.

Via MCP (Streamable HTTP)

To initiate monitoring, you'll send a POST request to the MCP endpoint https://health.getvda.ai/mcp with a JSON payload specifying your seed. The response will be a stream of monitoring events.

Example Request:

{
  "agent_id": "dynamic_health_monitor",
  "method": "monitor",
  "params": {
    "seed_type": "domain",
    "seed_value": "my-awesome-app.com"
  }
}

Example Response (abbreviated stream):

{
  "event_type": "service_discovered",
  "service_id": "api-gateway-01",
  "service_url": "https://api.my-awesome-app.com",
  "service_type": "HTTP"
}
{
  "event_type": "health_update",
  "service_id": "api-gateway-01",
  "status": "healthy",
  "latency_ms": 50,
  "timestamp": 1678886400
}
{
  "event_type": "root_cause_identified",
  "root_cause_service": "database-replica-03",
  "dependent_failures": ["api-gateway-01", "user-service-02"],
  "description": "Database replica experiencing high latency, impacting dependent services."
}

Via A2A (Message/Send)

For agent-to-agent communication, you'll use the message/send endpoint with a similar JSON payload.

Example Request:

{
  "recipient_agent_id": "dynamic_health_monitor",
  "payload": {
    "method": "monitor",
    "params": {
      "seed_type": "github_repo",
      "seed_value": "https://github.com/my-org/my-app"
    }
  }
}

The Dynamic Health Monitor's discovery capabilities (methods like initialize, tools, list) are provided free of charge, allowing you to explore its potential without commitment. However, the execution of active monitoring, which involves continuous health checks and intelligent analysis, is metered via Nevermined x402 micropayments. This ensures a fair and transparent pricing model based on your actual usage.

Stop wasting time on manual monitoring configuration and embrace the future of autonomous health checks.

Discover more VDA agents at https://agents.getvda.ai/agents

Traced LLM MCP Proxy: Gemini Completions with OpenTelemetry Tracing

mikerawsonnz — Mon, 10 Aug 2026 06:08:12 +0000

Tracing Your Gemini Calls with `Traced LLM MCP Proxy`

As developers, we often integrate Large Language Models (LLMs) into our applications. While powerful, debugging and monitoring these integrations can be a challenge. How do you track the performance of your LLM calls? How do you know which part of your system is contributing to latency? This is where distributed tracing comes in, and specifically, where our Traced LLM MCP Proxy agent shines.

The Traced LLM MCP Proxy addresses the problem of gaining visibility into your Gemini (Vertex AI) LLM completions. It acts as a transparent proxy, wrapping your Gemini calls in OpenTelemetry trace spans. This means you can easily see the duration of your LLM interactions, identify bottlenecks, and correlate them with other operations in your distributed system. The best part? It returns not just the LLM's answer, but also the trace and span IDs, allowing you to easily link the response back to your observability platform.

This agent is built using a robust stack of open-source libraries, including anthropic (likely for internal agent messaging or a related LLM if not specifically Gemini), cryptography (for secure communication), langchain-core (for LLM interaction abstractions), mcp (the Multi-Agent Communication Protocol framework), opentelemetry-exporter-otlp-proto-http (for exporting traces), and opentelemetry-sdk (the OpenTelemetry SDK itself).

How to Call `Traced LLM MCP Proxy`

You can interact with the Traced LLM MCP Proxy agent using two primary methods: over MCP's streamable-http interface or via A2A (Agent-to-Agent) messaging.

Over MCP (streamable-http)

This method is ideal for direct client-to-agent communication, often from a web application or a backend service. You'll make a POST request to the MCP endpoint with your Gemini completion request.

MCP Endpoint: https://anthropic-cryptography-langchain-d8b8c4.getvda.ai/mcp

Example Request:

{
  "agent_id": "traced-llm-mcp-proxy",
  "method": "complete",
  "params": {
    "model_name": "gemini-pro",
    "prompt": "Explain the concept of quantum entanglement in simple terms."
  }
}

Example Response:

{
  "result": {
    "text": "Quantum entanglement is a bizarre phenomenon...",
    "trace_id": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
    "span_id": "q1r2s3t4u5v6w7x8"
  },
  "status": "success"
}

Over A2A (message/send)

For agent-to-agent communication within the Multi-Agent Communication Protocol network, you'd use the message/send endpoint. This allows other agents to leverage the tracing capabilities of the Traced LLM MCP Proxy.

Example Request:

{
  "to": "traced-llm-mcp-proxy",
  "method": "complete",
  "params": {
    "model_name": "gemini-pro",
    "prompt": "What are the benefits of using a microservices architecture?"
  }
}

Example Response:

{
  "from": "traced-llm-mcp-proxy",
  "result": {
    "text": "Microservices architecture offers several benefits...",
    "trace_id": "b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6a1",
    "span_id": "r2s3t4u5v6w7x8q1"
  },
  "status": "success"
}

Metered Execution

It's important to note that while agent discovery operations like initialize, tools, and list are free, the execution of the complete method (and any other computationally intensive operations) is metered. This agent utilizes Nevermined x402 micropayments for its execution, ensuring fair usage and sustainability for the agent's operation.

By integrating Traced LLM MCP Proxy into your development workflow, you gain invaluable insights into your Gemini LLM interactions, making your applications more robust and easier to debug.

Discover more powerful agents at https://agents.getvda.ai/agents

Authenticated MCP JWT Agent: JWT-gated LLM Gateway

mikerawsonnz — Mon, 03 Aug 2026 06:04:27 +0000

Securing Your LLM Gateway with Authenticated MCP JWT Agent

In today's AI-driven landscape, leveraging Large Language Models (LLMs) is becoming increasingly common. However, directly exposing LLMs to the public can raise security and cost concerns. How do you ensure only authorized users can access your powerful Gemini models, and how do you manage that access efficiently?

This is where the Authenticated MCP JWT Agent steps in. This innovative agent provides a robust, JWT-gated LLM gateway, allowing you to authenticate users before they can access your LangChain-powered Gemini completions. Unauthenticated calls are simply rejected, providing a crucial layer of security and access control.

The Problem It Solves

Imagine you've built an amazing application that uses Gemini to generate creative content, summarize documents, or answer complex questions. You want to offer this as a service, but you need to:

Restrict access: Only paying subscribers or authorized internal users should be able to make requests.
Prevent abuse: Stop malicious actors from flooding your LLM with requests, incurring unnecessary costs.
Simplify integration: Provide a clear and secure API for your frontend or other services to interact with the LLM.

The Authenticated MCP JWT Agent addresses these challenges by acting as a secure intermediary. It leverages bcrypt for password hashing, python-jose for JWT handling, and langchain-core to orchestrate interactions with a Vertex AI Gemini model.

How to Call It

The agent exposes its functionality over the Message Control Protocol (MCP) using both streamable-http for direct HTTP interactions and message/send for asynchronous, message-based communication.

Calling via `streamable-http`

For direct, real-time interactions, you can use streamable-http. First, ensure you have a valid JWT. The agent expects a Bearer token in the Authorization header.

Endpoint: https://bcrypt-langchain-core-mcp-97246c.getvda.ai/mcp

Request (POST):

{
  "method": "complete",
  "params": {
    "prompt": "What are the key benefits of using a secure LLM gateway?"
  }
}

Example Response (200 OK):

{
  "result": "A secure LLM gateway offers several key benefits, including enhanced data privacy, controlled access to expensive models, prevention of API abuse, and streamlined authentication for developers. It acts as a protective layer, ensuring that only authorized requests reach your underlying LLM infrastructure."
}

If your JWT is invalid or missing, you'll receive a 401 Unauthorized error.

Calling via `message/send`

For asynchronous or event-driven scenarios, you can use the message/send method. This requires sending a message with the agent_id and the parameters for the complete method. The authentication token will still be required in the message headers or body depending on your MCP client implementation.

Request (POST):

{
  "method": "message/send",
  "params": {
    "agent_id": "bcrypt-langchain-core-mcp-97246c.getvda.ai",
    "method": "complete",
    "parameters": {
      "prompt": "Explain the concept of zero-shot learning in LLMs."
    }
  }
}

Example Response (200 OK):

{
  "status": "Message sent successfully.",
  "message_id": "some-unique-message-id"
}

The actual completion result would then be delivered asynchronously through a separate channel or callback, depending on your MCP setup.

Discovery and Metering

It's important to note that discovering the agent's capabilities (using initialize, tools/list) is free of charge. You can explore its available methods and parameters without incurring costs. However, executing the complete method, which involves interacting with the Gemini LLM, is metered. This execution is facilitated through Nevermined x402 micropayments, ensuring fair usage and transparent billing for your LLM interactions.

This agent provides a powerful and secure way to integrate LLMs into your applications, ensuring that your valuable AI resources are protected and accessed only by those who are authorized.

Learn more about VDA agents: https://agents.getvda.ai/agents

GOSCE Portfolio Router: Smart Routing for Verified Agents

mikerawsonnz — Mon, 03 Aug 2026 06:04:19 +0000

Streamlining Agent Interactions with the GOSCE Portfolio Router

Navigating the ever-growing landscape of specialized agents can be a daunting task for developers. Imagine needing to leverage an agent for sentiment analysis, another for image recognition, and yet another for natural language generation. Each might have its own endpoint, authentication method, and API signature. This fragmentation creates significant overhead, slowing down development and increasing maintenance burdens.

This is precisely the problem the GOSCE Portfolio Router solves. It acts as a single, intelligent entry point to a curated and verified portfolio of agents, routing your requests to the most appropriate agent based on its advertised capabilities. Think of it as a quality-assured broker, not just a simple directory. Instead of you needing to know the specific agent for a task, you simply tell the router what you need, and it handles the rest. This significantly simplifies your integration efforts, allowing you to focus on your application's core logic rather than agent discovery and integration.

Let's explore how to interact with the GOSCE Portfolio Router.

Calling the Router via MCP (Streamable-HTTP)

The GOSCE Portfolio Router exposes a convenient Streamable-HTTP endpoint for direct interaction. This is ideal for applications that need to orchestrate agent calls and receive streaming responses.

Here's an example of a simple request to the router's /selftest probe, which demonstrates its routing capabilities by asking for an agent that can perform "text summarization":

{
  "capability": "text summarization",
  "request_id": "unique-request-id-123"
}

And here's a snippet of the kind of response you might receive from the router, showing it successfully identified and routed to a suitable agent:

{
  "status": "success",
  "routed_to": "summarization-agent-v1.2",
  "agent_response": {
    "summary": "This is a concise summary of the provided text."
  },
  "router_metadata": {
    "latency_ms": 45,
    "agent_version": "1.2.0"
  }
}

Notice how the routed_to field explicitly states which agent handled the request, and agent_response contains the actual output from that agent. The router_metadata provides valuable insights into the routing process.

Calling the Router via A2A (Message/Send)

For agent-to-agent communication or scenarios where a more asynchronous, message-based approach is preferred, the Router also supports the message/send method. This allows agents themselves to leverage the router for inter-agent communication without needing to know the specific endpoints of their peers.

A similar request structure applies:

{
  "method": "send",
  "payload": {
    "capability": "image classification",
    "image_url": "https://example.com/image.jpg"
  },
  "destination": "router.getvda.ai"
}

And a corresponding response:

{
  "status": "success",
  "routed_to": "image-classifier-pro",
  "agent_response": {
    "classifications": ["cat", "mammal", "pet"],
    "confidence": [0.98, 0.95, 0.90]
  }
}

Discovery and Metering

While execution requests are metered, you can freely explore the capabilities of the agents managed by the GOSCE Portfolio Router. Discovery operations, such as initialize or tools/list, are not subject to metering. This allows you to programmatically understand the available services without incurring costs.

Execution of agent capabilities, however, leverages Nevermined x402 micropayments. This ensures a fair and transparent payment model for the valuable services provided by the underlying agents.

The GOSCE Portfolio Router empowers developers to build more sophisticated and robust applications by abstracting away the complexities of managing multiple agents. By providing a unified interface and intelligent routing, it significantly reduces development time and fosters a more efficient agent ecosystem.

Explore the full range of agents integrated with the GOSCE Portfolio Router at: https://agents.getvda.ai/agents

Authenticated Multi-LLM Agent: Google-OAuth-gated Gemini

mikerawsonnz — Mon, 15 Jun 2026 06:06:41 +0000

Securely Accessing LLMs with Authenticated Multi-LLM Agent

In today's interconnected development landscape, integrating Large Language Models (LLMs) into applications is increasingly common. However, ensuring secure and controlled access to these powerful models, especially when dealing with sensitive user data or internal applications, presents a significant challenge. How do you verify who is making the request and then gate access to your LLM resources accordingly?

This is where the Authenticated Multi-LLM Agent comes in. This powerful agent provides a Google-OAuth-gated LLM gateway, allowing you to seamlessly verify a Google ID token and then run a Gemini (Vertex AI) completion for the authenticated caller. It's built upon a robust composition of anthropic, google-auth-oauthlib, mcp, and openai, offering a flexible and secure solution for your LLM access control needs.

The Problem It Solves

Imagine you're building an internal tool that leverages a powerful LLM for data analysis. You want to ensure that only authenticated employees can access this LLM and that their usage can be tracked. Manually implementing Google OAuth verification, managing API keys for different LLMs, and routing requests securely can be a complex and error-prone process.

The Authenticated Multi-LLM Agent simplifies this by:

Centralizing Authentication: It handles the Google ID token verification process, ensuring that only legitimate users with valid Google accounts can proceed.
Gating LLM Access: Once authenticated, it acts as a secure gateway, proxying requests to your chosen LLM (Gemini in this case) on behalf of the verified user.
Streamlining Integration: It provides a unified interface, abstracting away the complexities of interacting directly with Google OAuth and the LLM provider.
Enabling Multi-LLM Strategies: While this specific agent focuses on Gemini, its underlying composition allows for future expansion to other LLMs, providing a flexible foundation for your multi-LLM architecture.

How to Call It

The Authenticated Multi-LLM Agent can be invoked over both streamable-http (for real-time interactions) and A2A (for asynchronous messaging). The MCP endpoint for this agent is: https://anthropic-google-auth-oauthlib-mc-70ac16.getvda.ai/mcp.

Calling over streamable-http

To call the agent over streamable-http, you'll send a POST request to the MCP endpoint with a JSON body containing your Google ID token and the prompt for the Gemini LLM.

Request Example:

{
  "google_id_token": "YOUR_GOOGLE_ID_TOKEN_HERE",
  "llm_prompt": "Explain the concept of quantum entanglement in simple terms."
}

Response Example (successful completion):

{
  "status": "success",
  "llm_response": "Quantum entanglement is a phenomenon where two or more particles become linked in such a way that they share the same fate, no matter how far apart they are.  If you measure a property of one entangled particle, you instantly know the corresponding property of the other, even if it's light-years away. It's like having two coins that, no matter how much you flip them independently, always land on the same side – heads and heads, or tails and tails. This 'spooky action at a distance,' as Einstein called it, is a fundamental aspect of quantum mechanics."
}

Calling over A2A (message/send)

For asynchronous interactions, you can use the A2A message/send method, providing the same JSON payload as the data field.

Request Example:

{
  "recipient": "https://anthropic-google-auth-oauthlib-mc-70ac16.getvda.ai/mcp",
  "data": {
    "google_id_token": "YOUR_GOOGLE_ID_TOKEN_HERE",
    "llm_prompt": "What are the main applications of machine learning in healthcare?"
  }
}

Response Example (successful completion):

{
  "status": "success",
  "llm_response": "Machine learning is revolutionizing healthcare in many ways, including: disease diagnosis and prediction, drug discovery and development, personalized treatment plans, medical image analysis, and robotic surgery assistance."
}

Metered Execution

While the discovery of agents (via initialize/tools/list) is free, execution of the Authenticated Multi-LLM Agent is metered. This agent leverages Nevermined x402 micropayments for tracking and billing usage, ensuring a fair and transparent consumption model.

Discover more powerful agents and unlock new possibilities for your applications.

https://agents.getvda.ai/agents

Traced LLM Proxy: Gemini with OpenTelemetry & Trace IDs

mikerawsonnz — Mon, 08 Jun 2026 06:05:37 +0000

Tracing Your LLM Calls with the Agent Traced LLM Proxy

In the world of AI-powered applications, understanding the inner workings of your LLM calls is crucial for debugging, performance optimization, and gaining insights. While LLMs offer incredible capabilities, their "black box" nature can make tracing difficult. This is where the Agent Traced LLM Proxy comes in – a powerful tool that wraps your Gemini (Vertex AI) completion requests in OpenTelemetry trace spans, providing invaluable visibility into your LLM interactions.

The Problem It Solves

Imagine your application makes numerous calls to Gemini for various tasks. When something goes wrong, or you want to understand latency, pinpointing the exact LLM interaction that caused the issue can be a nightmare. Traditional logging provides some clues, but it lacks the rich, contextual information that distributed tracing offers. The Agent Traced LLM Proxy solves this by automatically instrumenting your Gemini calls, giving you a detailed trace of each request, including its duration, and other relevant metadata. This means you can easily identify bottlenecks, troubleshoot errors, and gain a comprehensive view of your LLM's performance within your larger system.

How to Call It Over MCP (Streamable-HTTP)

The Traced LLM Proxy is easily accessible via the MCP (Message Control Protocol) using streamable-HTTP. This allows for a straightforward integration into your existing services.

To make a completion request, you'll send a POST request to the MCP endpoint: https://anthropic-mcp-opentelemetry-api-264025.getvda.ai/mcp.

Here's an example of a JSON request body:

{
  "serviceId": "anthropic-mcp-opentelemetry-api-264025.getvda.ai/mcp",
  "method": "call",
  "params": {
    "model": "gemini-pro",
    "prompt": "Explain the concept of quantum entanglement in simple terms."
  }
}

The response will include the LLM's completion along with the OpenTelemetry trace and span IDs:

{
  "result": {
    "completion": "Quantum entanglement is a phenomenon where two or more particles become linked in such a way that they share the same fate...",
    "trace_id": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
    "span_id": "q1r2s3t4u5v6w7x8"
  }
}

How to Call It Over A2A (Message/Send)

For Agent-to-Agent (A2A) communication, you can use the message/send endpoint. This is particularly useful in multi-agent architectures where agents need to interact with the Traced LLM Proxy.

The A2A request structure will look similar:

{
  "serviceId": "anthropic-mcp-opentelemetry-api-264025.getvda.ai/mcp",
  "method": "message/send",
  "params": {
    "payload": {
      "model": "gemini-pro",
      "prompt": "What are the benefits of using a microservices architecture?"
    }
  }
}

The response will follow the same format as the MCP example, containing the completion, trace_id, and span_id.

Discovery and Metering

It's important to note that the discovery operations, such as initialize and tools/list, are completely free. This allows you to explore the agent's capabilities and understand its available methods without incurring any costs. However, the execution of LLM completion requests through the Traced LLM Proxy is metered. This metering is handled via Nevermined x402 micropayments, ensuring a transparent and fair pricing model based on your usage.

By integrating the Agent Traced LLM Proxy into your development workflow, you gain unprecedented visibility into your LLM interactions, empowering you to build more robust, performant, and observable AI applications.

Discover more agents and their capabilities at: https://agents.getvda.ai/agents

Structured Output: Gemini 2.5 Flash & Instructor for Validated JSON

mikerawsonnz — Mon, 08 Jun 2026 06:05:30 +0000

Generating Structured Data with Ease: Introducing the Structured Output MCP Agent

Working with large language models often involves wrestling their free-form text output into a structured format for downstream processing. This "parsing tax" can be a significant bottleneck, requiring complex regex, error handling, and validation logic. What if you could simply tell the LLM the exact JSON schema you need, and it reliably delivered?

Enter the Structured Output MCP Agent. This powerful agent leverages the capabilities of instructor over Google's Gemini 2.5 Flash on Vertex AI, combined with fastmcp, to transform a natural language prompt and a JSON schema into validated, typed JSON output. It's designed to eliminate the parsing tax, making your LLM integrations cleaner, more robust, and significantly faster.

The Problem It Solves

Imagine you're building an application that extracts information from user queries – say, a booking system that needs to identify the destination, dates, and number of guests. Without structured output, you'd prompt the LLM, receive a text response, and then write custom code to parse that text, handle potential ambiguities, and validate the extracted data against your expected types (e.g., ensuring dates are actual dates, and guest counts are integers). This is brittle and time-consuming.

The Structured Output MCP Agent solves this by:

Guaranteed Schema Adherence: It forces the LLM to conform its output to your specified JSON schema, dramatically reducing parsing errors.
Type Safety: The output is not just valid JSON, but also adheres to the data types defined in your schema.
Reduced Development Time: No more writing custom parsing and validation logic.
Increased Reliability: Consistent, predictable output makes your applications more robust.

How to Call It

You can interact with the Structured Output MCP Agent using either streamable-http for direct HTTP requests or A2A (Agent-to-Agent) messaging for more complex agent orchestrations.

The agent's MCP endpoint is: https://fastmcp-instructor-72225f.getvda.ai/mcp

Using Streamable-HTTP

For direct HTTP requests, you'll send a POST request to the MCP endpoint with a JSON body.

Example Request:

{
  "method": "structured_output",
  "params": {
    "prompt": "Extract the user's name, their preferred contact method (email or phone), and the message they want to send.",
    "schema": {
      "type": "object",
      "properties": {
        "user_name": { "type": "string", "description": "The full name of the user" },
        "contact_method": { "type": "string", "enum": ["email", "phone"], "description": "Preferred contact method" },
        "message": { "type": "string", "description": "The message to send" }
      },
      "required": ["user_name", "contact_method", "message"]
    },
    "user_input": "My name is Alice Wonderland, you can reach me at alice@example.com. I'd like to inquire about the new features."
  }
}

Example Response:

{
  "result": {
    "user_name": "Alice Wonderland",
    "contact_method": "email",
    "message": "I'd like to inquire about the new features."
  }
}

Using A2A (message/send)

For agent-to-agent communication, you'd use the message/send method, encapsulating the structured_output call within the payload.

Example Request (A2A):

{
  "method": "message/send",
  "params": {
    "recipient_did": "did:vda:fastmcp-instructor-72225f.getvda.ai",
    "payload": {
      "method": "structured_output",
      "params": {
        "prompt": "Extract the user's name, their preferred contact method (email or phone), and the message they want to send.",
        "schema": {
          "type": "object",
          "properties": {
            "user_name": { "type": "string", "description": "The full name of the user" },
            "contact_method": { "type": "string", "enum": ["email", "phone"], "description": "Preferred contact method" },
            "message": { "type": "string", "description": "The message to send" }
          },
          "required": ["user_name", "contact_method", "message"]
        },
        "user_input": "My name is Bob The Builder. Please call me at 555-1234 to discuss the project."
      }
    }
  }
}

Example Response (A2A - simplified, actual response includes A2A envelope):

{
  "result": {
    "user_name": "Bob The Builder",
    "contact_method": "phone",
    "message": "to discuss the project."
  }
}

Discovery and Metering

You can discover the capabilities of this agent (and others) by using the initialize and tools/list methods, which are free to call. Agent execution, including the structured_output method, is metered via Nevermined x402 micropayments. This ensures fair usage and sustainable operation of the agent ecosystem.

Start building more robust and intelligent applications today by integrating the Structured Output MCP Agent!

https://agents.getvda.ai/agents

FastAPI Auth Token Service: Bcrypt Passwords & JWT Sessions

mikerawsonnz — Thu, 04 Jun 2026 15:43:42 +0000

Secure Authentication Simplified with FastAPI Auth Token Service

Building secure authentication into your applications can be a complex and time-consuming endeavor. From securely hashing passwords to issuing and verifying session tokens, there are many potential pitfalls. Manually implementing these features often leads to security vulnerabilities and delays in product development.

This is where the FastAPI Auth Token Service comes in. This powerful agent, built on bcrypt for robust password hashing and python-jose for JWT handling, provides a streamlined and secure solution for managing user authentication. It abstracts away the complexities, allowing you to integrate secure user sessions with minimal effort.

How it Solves the Problem

The FastAPI Auth Token Service tackles two critical aspects of authentication:

Secure Password Hashing: It uses bcrypt, a cryptographically strong hashing function, to securely store user passwords. This prevents brute-force attacks and ensures that even if your database is compromised, user passwords remain protected.
JWT Session Management: It issues and verifies JSON Web Tokens (JWTs) for session management. JWTs are a secure and stateless way to transmit information between parties, allowing your application to authenticate users without storing session data on the server side. This improves scalability and reduces server load.

Calling the Agent over MCP (Streamable-HTTP)

You can interact with the FastAPI Auth Token Service directly over its MCP endpoint using streamable-http. This is ideal for real-time authentication flows where your application needs to generate or validate tokens.

Endpoint: https://bcrypt-python-jose-d0e0d0.getvda.ai/mcp

Example: Hashing a Password

To hash a password, send a POST request with the following JSON payload:

{
  "service": "hash_password",
  "password": "mySecurePassword123!"
}

The agent will respond with the hashed password:

{
  "hashed_password": "$2b$12$EXAMPLE_HASH_STRING_HERE"
}

Example: Issuing a JWT Token

To issue a JWT token, provide the user's ID and any additional claims you want to include in the token:

{
  "service": "create_token",
  "user_id": "user123",
  "claims": {
    "role": "admin"
  }
}

The agent will return a signed JWT:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidXNlcjEyMyIsInJvbGUiOiJhZG1pbiIsImV4cCI6MTY3ODg4NjQwMH0.EXAMPLE_JWT_SIGNATURE"
}

Example: Verifying a JWT Token

To verify a JWT token and retrieve its claims:

{
  "service": "verify_token",
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidXNlcjEyMyIsInJvbGUiOiJhZG1pbiIsImV4cCI6MTY3ODg4NjQwMH0.EXAMPLE_JWT_SIGNATURE"
}

The agent will respond with the token's payload if valid:

{
  "claims": {
    "user_id": "user123",
    "role": "admin",
    "exp": 1678886400
  }
}

Calling the Agent over A2A (Message/Send)

For asynchronous or background tasks, you can use A2A (Agent-to-Agent) communication via message/send. This is particularly useful for scenarios where immediate responses aren't critical, such as processing user registrations in a queue. The JSON payload structure for message/send will be identical to the MCP examples above, but the communication channel will differ.

Discovery and Metering

While discovering the capabilities of this agent (via initialize/tools/list) is free, execution of its services is metered. This agent leverages Nevermined x402 micropayments for execution. This ensures a fair and efficient ecosystem for agent services.

By integrating the FastAPI Auth Token Service, you can significantly reduce development time and enhance the security posture of your applications. Focus on your core business logic while offloading complex authentication tasks to a reliable and secure agent.

Discover more powerful agents at https://getvda.ai/agents

DEV Community: mikerawsonnz

Dynamic Health Monitor: Auto-discovering Monitoring for Your Services

Effortless Health Monitoring with Dynamic Health Monitor

How to Interact with Dynamic Health Monitor

Via MCP (Streamable HTTP)

Via A2A (Message/Send)

Traced LLM MCP Proxy: Gemini Completions with OpenTelemetry Tracing

Tracing Your Gemini Calls with Traced LLM MCP Proxy

How to Call Traced LLM MCP Proxy

Over MCP (streamable-http)

Over A2A (message/send)

Metered Execution

Authenticated MCP JWT Agent: JWT-gated LLM Gateway

Securing Your LLM Gateway with Authenticated MCP JWT Agent

The Problem It Solves

How to Call It

Calling via streamable-http

Calling via message/send

Discovery and Metering

GOSCE Portfolio Router: Smart Routing for Verified Agents

Streamlining Agent Interactions with the GOSCE Portfolio Router

Calling the Router via MCP (Streamable-HTTP)

Calling the Router via A2A (Message/Send)

Discovery and Metering

Authenticated Multi-LLM Agent: Google-OAuth-gated Gemini

Securely Accessing LLMs with Authenticated Multi-LLM Agent

The Problem It Solves

How to Call It

Calling over streamable-http

Calling over A2A (message/send)

Metered Execution

Traced LLM Proxy: Gemini with OpenTelemetry & Trace IDs

Tracing Your LLM Calls with the Agent Traced LLM Proxy

The Problem It Solves

How to Call It Over MCP (Streamable-HTTP)

How to Call It Over A2A (Message/Send)

Discovery and Metering

Structured Output: Gemini 2.5 Flash & Instructor for Validated JSON

Generating Structured Data with Ease: Introducing the Structured Output MCP Agent

The Problem It Solves

How to Call It

Using Streamable-HTTP

Using A2A (message/send)

Discovery and Metering

FastAPI Auth Token Service: Bcrypt Passwords & JWT Sessions

Secure Authentication Simplified with FastAPI Auth Token Service

How it Solves the Problem

Calling the Agent over MCP (Streamable-HTTP)

Calling the Agent over A2A (Message/Send)

Discovery and Metering

Tracing Your Gemini Calls with `Traced LLM MCP Proxy`

How to Call `Traced LLM MCP Proxy`

Calling via `streamable-http`

Calling via `message/send`