Integrations

Akka runs on the JVM. All integrations use industry-standard Java APIs and client libraries. No proprietary adapters or Akka-specific wrappers are needed. If a Java client exists for it, you can use it in Akka.

AI & models

LLM providers are supported natively — 9 providers built into the SDK: Anthropic, OpenAI, Google AI Gemini, Google Cloud Vertex AI, AWS Bedrock, Ollama, LocalAI, Hugging Face, plus custom providers via the ModelProvider.Custom interface.

Agents — how Agents interact with AI models
Model provider details — configuration for each provider

Data & knowledge

Akka connects to any data store with a Java client library.

Vector databases: Pinecone, Weaviate, Qdrant, Chroma, pgvector — via their Java client libraries
Relational databases: PostgreSQL, MySQL — via R2DBC or JDBC
NoSQL databases: MongoDB, DynamoDB, Cassandra — via their Java client libraries
Search engines: Elasticsearch, OpenSearch — via their Java client libraries
Retrieval-Augmented Generation (RAG) — semantic search on vector databases to enrich AI model requests

No caching layer needed

Akka’s Entity components (Event Sourced Entities, Key Value Entities) are in-memory systems of durable record. All data is durable, immutable, and in-memory with sub-10ms access. There is no need for a separate cache like Redis. Your Entities are your cache — with persistence guarantees that Redis cannot provide.

Messaging & events

Akka-native first. Akka has built-in messaging capabilities that should be your primary path. These are durable, integrated with the runtime, and require no external infrastructure:

Component and service calls — invoke other services and components directly
Consumers — brokerless pub/sub, service-to-service eventing, event-driven consumption
Streaming — built-in stream processing

When you need to integrate with systems outside Akka, use external message brokers via their Java client libraries:

Message brokers — Kafka, Google Pub/Sub, Azure Event Hubs
Webhooks for external system callbacks — implement via HTTP Endpoints

APIs & protocols

Akka provides built-in support for exposing your services:

HTTP Endpoints — REST APIs with JSON
OpenAPI — schema generation (built-in)
WebSockets — real-time bidirectional communication (built-in)
gRPC Endpoints — high-performance APIs
MCP Endpoints — expose Agent functions to remote LLMs via @FunctionTool annotations

Agent protocol support

A2A, ACP, and MCP clients are baked into Akka’s Agent component. Agents natively consume tools and communicate with other Agents via all three protocols. No external libraries needed.

The Akka CLI also provides a built-in MCP server (akka mcp serve) that exposes CLI operations as MCP tools for Claude Desktop, VS Code, and Cursor.

Identity & security

Akka-native secret management (built-in) — project-level secrets injected as environment variables, supporting generic secrets, symmetric/asymmetric keys, TLS certificates, and CA bundles. Key rotation without environment variable changes. Values are never exposed in CLI or Console. See Manage secrets.
External secrets: Azure KeyVault integration (currently documented). See Manage external secrets.
Other external providers (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault) — via standard Java APIs.

Observability

OpenTelemetry metrics and logs exporting (built-in) — feed into any OTEL-compatible backend: Grafana, Datadog, New Relic, and others. See Observability and monitoring.