Universal Gateway

Fifteen databases. Five teams. Zero idea who has access to what.

Every system has its own credentials, monitoring, and rules. Eve is the execution layer between your apps and every system they touch — it decides how and whether anything actually happens.

How Eve Sits in Your Stack

Eve intercepts at the protocol level. Your applications connect to Eve, and Eve connects to everything else.

App A
App B
App C
↓
Eve Platform
Auth · RBAC · Pooling · TLS · Telemetry · Policy · Analytics
↓
Databases
PostgreSQL, MySQL, Redis, MongoDB, ...
↓
LLMs
OpenAI, Anthropic, Ollama, OpenRouter
↓
APIs
REST endpoints, webhooks
↓
Functions
Tools, serverless

Database Support

Native wire protocol support. Not API wrappers. Eve intercepts at the protocol level for real connection pooling, real transactions, and real observability.

DatabaseStatusWire ProtocolTransactionsPoolingAnalyticsMigrations
PostgreSQLPostgreSQL
Released
MySQLMySQL
Released
RedisRedis
Released
MongoDBMongoDB
Released
CassandraCassandra
Released
ClickHouseClickHouse
Released
PineconePinecone
Released
SnowflakeSnowflake
Coming Soon
OracleOracle
Coming Soon
SQL ServerSQL Server
Coming Soon
WeaviateWeaviate
Coming Soon
DatabricksDatabricks
Coming Soon

What Eve Supports Per Database

PostgreSQLPostgreSQL

Full SQL, COPY streaming, prepared statements, notifications

MySQLMySQL

Full SQL, charset handling, compression support

RedisRedis

400+ commands, JSON, Search, TimeSeries, Streams, Pub/Sub, PSYNC/AOF replication

MongoDBMongoDB

Aggregation pipelines, change streams, session transactions

CassandraCassandra

CQL support, token-aware routing

ClickHouseClickHouse

OLAP analytics, columnar storage, HTTP + native protocols

PineconePinecone

Vector search, embedding storage, similarity queries

LLM Providers

One API, every model. Swap providers without changing a line of code. Zero vendor lock-in.

ProviderDefault ModelStreamingTool CallingCustom URL
OpenAIOpenAI
gpt-4o
AnthropicAnthropic
claude-sonnet-4-5
OllamaOllama
llama3.2
OpenRouterOpenRouter
moonshotai/kimi-k2

Key Capabilities

Everything you need at the gateway layer. No sidecar proxies, no extra infrastructure.

A different protocol for every database

Eve speaks each database's native protocol. Real connection pooling, real transactions, real observability.

  • RESP, PostgreSQL, MySQL, MongoDB, ClickHouse, Oracle wire protocols
  • 200+ Redis commands including JSON, Search, Streams, PSYNC/AOF
  • MongoDB aggregation pipelines and change streams

Credentials scattered across every system

One auth layer across every endpoint. JWT-based identity that inherits permissions from each system. If PostgreSQL has row-level security, Eve uses it.

  • No privilege escalation
  • Organization-scoped credential management
  • Audit logging with service/command filtering

Connection Pooling & TLS

Per-endpoint connection managers with configurable pool sizes (up to 100 max). Credential management with separate secure storage. TLS termination built into the gateway layer.

  • Zero-config switching between backends
  • Automatic credential rotation
  • mTLS support

Multi-Provider LLM Access

OpenAI, Anthropic, Ollama, OpenRouter through the same API surface. Swap providers without changing code. Self-host with Ollama for air-gapped deployments.

  • Streaming and tool calling across all providers
  • Custom base URL support
  • Zero vendor lock-in

Something broke and nobody saw it coming

Metrics, tracing, and logging from every system in one place. DogStatsD and Prometheus out of the box. No agents to deploy.

  • DogStatsD + Prometheus dual export with delta and cumulative temporality
  • Distributed tracing with automatic context propagation
  • Per-command latency histograms, error counters, and throughput gauges

Someone ran FLUSHALL in production

Block, warn, or observe any command across every database — before it executes. 15+ presets and automatic risk classification.

  • Block / Warn / Observe modes configurable per endpoint
  • Built-in presets: production, strict, flush, keys, ACL, debug, and more
  • Full audit trail with service attribution and query recording

How It Works

1

Point your traffic through Eve

Update your connection string. Eve intercepts at the protocol level with zero code changes.

2

Eve handles the rest

Auth, pooling, TLS, routing, and observability are handled automatically at the proxy layer.

3

Add endpoints as you grow

New databases, LLM providers, or APIs become endpoints in the same system. Same auth, same RBAC, same API.

Performance & Infrastructure

Built for production workloads at scale.

< 100μs
Proxy Latency

Target added latency per operation at the wire protocol level

~2ns
Metrics Overhead

Thread-sharded atomics with cache-line padding for near-zero telemetry cost

Pingora
Load Balancer

Built on Cloudflare's Pingora with round-robin, HTTP/2, and health checking

3 Modes
Policy Enforcement

Block, warn, or observe — command-level control per endpoint with 15+ presets

18+
Endpoint Types

Databases, LLMs, APIs, Lambda functions, vector stores, tools endpoints

2 Exports
Metrics Formats

DogStatsD (UDP) and Prometheus exposition — plug into your existing stack

Stop flying blind.

Connect your first system and see what unified auth and observability actually feels like.