DOCSEARCHbyAlgolia
Submit Docs

Aklivity Documentation

website·Indexed 33 days ago

https://docs.aklivity.io/

Reference documentation for Aklivity configuration, featuring a wide array of bindings for adapting data streams across protocols including Kafka, HTTP, gRPC, AsyncAPI, OpenAPI, TCP, TLS, and SOCKS5, as well as data validation models for strings and floats.

Tokens
257.4K
Snippets
1.4K
Records
1.9K
Agent score
61%

What's inside Aklivity

  1. Overview of mcp-http client binding

    The mcp-http client binding terminates MCP tools/list, resources/list, and resources/templates/list requests from the configuration. It expands tools/call and resources/read requests into upstream HTTP requests. Unlike the proxy binding, a client binding never references an exit at the top level or per route.

  2. Overview of MCP Backend Bindings

    Backend bindings are specialized client kind bindings that connect directly to a backend and expose a fixed, built-in set of MCP tools. Unlike mcp-http or mcp-openapi, they do not require a hand-authored tool list or an OpenAPI document. The tool calls go directly to the backend via options.server (or options.servers), bypassing any intermediate REST API or MCP server.

  3. Overview of the mqtt-kafka proxy binding

    The mqtt-kafka proxy binding adapts MQTT topic streams to Kafka topic streams. It allows an mqtt server binding to accept client connections and proxy MQTT messages and session states onto specified Kafka topics.
    mqtt_kafka_proxy:
  type: mqtt-kafka
  kind: proxy
  options:
    server: mqtt-1.example.com:1883
    topics:
      sessions: mqtt-sessions
      messages: mqtt-messages
      retained: mqtt-retained
    clients:
      - place/{identity}/#
  routes:
    - when:
        - publish:
            - topic: place/+/device/#
        - subscribe:
            - topic: place/+/device/#
      with:
        messages: mqtt-devices
      exit: kafka_cache_client
  exit: kafka_cache_client

  5. Overview of mcp-http Binding

    The mcp-http binding accepts mcp streams and produces http streams. It handles the termination of tools/list, resources/list, and resources/templates/list based on configuration and expands tools/call and resources/read into upstream HTTP requests. It can be configured as either a client or a proxy.

  6. Overview of aws-secrets Vault

    The aws-secrets vault is a Zilla runtime vault that enables remote access to AWS services from an EC2 instance. It is typically used in conjunction with a tls binding vault property to reference secrets using Amazon Resource Names (ARNs). This vault is available in Zilla Plus.

  7. Overview of smux stream multiplexing

    The smux binding implements the smux protocol, which allows multiple independent streams to be multiplexed over a single network connection. It supports two operational modes: server (decoding inbound framed streams into application streams) and client (encoding application streams into a single framed network connection).

  8. Overview of Zilla Plus Secure Private Access for Amazon MSK

    Zilla Plus for Amazon MSK provides a Secure Private Access proxy that allows authorized Kafka clients in cross-account VPCs to securely connect, publish, and subscribe to Amazon MSK Serverless clusters. It acts as an auto-scaling, stateless proxy layer deployed in a private VPC that handles authentication and routing without requiring configuration changes to the MSK cluster itself. Key technical features include:

    • End-to-end TLS handshake support.
    • Deployment behind a Network Load Balancer (NLB) for high availability.
    • Integration with AWS Nitro Enclaves for automated certificate renewal.
    • Support for Custom Wildcard DNS and Route 53 Hosted Zone integration to provide a unified domain name for Kafka clients.

  9. Overview of mcp-openapi client binding

    The mcp-openapi client binding parses OpenAPI specifications from a catalog and compiles routed operations into a generated composite mcp-http proxy binding. This allows OpenAPI operations—selected individually, by spec, by tag, or via glob patterns—to be exposed as MCP tools and resources with a single specification parse.
    mcp_openapi_client:
  type: mcp-openapi
  kind: client
  options:
    specs:
      github:
        catalog:
          my_catalog:
            subject: github
            version: latest
        security:
          bearerAuth: my_guard
    tools:
      create_pr:
        description: Create a pull request to merge one branch into another.
  routes:
    - when:
        - tool: create_pr
      with:
        spec: github
        operation: create_pr
    - when:
        - resource: read_order
      with:
        spec: github
        operation: read_order
    - with:
        spec: github
        tag: issues

  10. Overview of Zilla Governance Policies

    Policies are reusable, Gateway-enforced governance rules used to reject or record traffic that does not match specific naming conventions, partition limits, or other defined rules. They operate independently of a principal's ACLs or quotas. Policies are scoped per environment and can be attached to Virtual Clusters or Gateway Groups.

  11. Overview of mcp-openapi Binding

    The mcp-openapi binding reads OpenAPI specifications from a catalog and compiles routed operations into a generated mcp-http proxy. This exposes OpenAPI operations as MCP tools and resources without requiring protocol-specific code. Operations can be selected individually, by specification, by tag, or via glob patterns.

  12. Overview of AI Gateway capabilities

    The AI Gateway provides a secure layer for LLM access and agent connectivity. Key capabilities include:

    • MCP-Native Support: First-class support for Model Context Protocol (MCP) with server, proxy, and client bindings.
    • Virtual Server: Aggregates multiple MCP servers behind a single endpoint, routing tool calls by toolkit name.
    • OAuth Guard: Enforces JWT bearer authentication at the gateway and manages client credentials/token exchange for outbound calls to upstreams.
    • Listing Cache: Caches tool, prompt, and resource listings to reduce upstream server load, with configurable TTL.
    • Distributed Stores: Supports in-memory storage for single instances or shared state (via Redis or Hazelcast) for load-balanced replicas.
    • Spec-Driven Tools: Automatically derives MCP tools and resources from OpenAPI documents.
    • MCP Observability: Provides per-method counters and histograms for MCP calls (dimensioned by tool and outcome), exportable via Prometheus or OTLP.
    • Semantic Models & Embeddings: Supports text-to-vector providers (Local GloVe, OpenAI, AWS Bedrock, IBM watsonx.ai) to reject tool calls or responses based on cosine-similarity thresholds.