Open source · Apache License 2.0
Open source AI gateway and security you can inspect
An open source AI gateway lets you read the code that sits in your security path. The core of DeepintShield is published on GitHub under the Apache License 2.0, so you can inspect how requests are checked, run it on your own infrastructure and test the published benchmarks against your own workload.
- Apache License 2.0
- Public repository on GitHub
- Benchmarks published with their conditions

Why an open source AI gateway matters for security
A security layer sits in the path of every prompt and response, so you should be able to check what it does. How we handle data is set out on the trust and security page.
Inspect
Read the code that checks your traffic: no black box between your users and your models.
Self-host
Run the core on your own infrastructure under the Apache License 2.0, without asking us first.
Contribute
Report issues, suggest changes and propose integrations through the public repository on GitHub.
Run it yourself
Clone the repository and follow its README to run the core. The docs use http://localhost:8080 as the address of a local gateway.
Then point any OpenAI client at your gateway with a virtual key. The examples use the managed cloud address from the quick start; swap in your own host. For a supported production install, see self-hosted deployment.
- Unified OpenAI-style routes under
/v1 - Virtual keys start with
sk-ds- - Python SDK 3.2.3 needs Python 3.10 or newer
pip install openai
export OPENAI_BASE_URL="https://app.deepintshield.com/v1"
export OPENAI_API_KEY="sk-ds-your-virtual-key"from openai import OpenAI
with OpenAI() as client:
response = client.chat.completions.create(
model="openai/gpt-4o-mini",
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)python -m pip install --upgrade "deepintshield==3.2.3"Benchmarks you can reproduce
These are the performance figures published in the DeepintShield docs, each with the conditions it was measured under. The docs describe them as workload- and environment-specific, not as service levels, and none of them is an end-to-end latency figure.
| What was measured | Published figure | Conditions |
|---|---|---|
| Reuse of an eligible deterministic guard decision | About 1.42 µs | Local microbenchmark with no I/O |
| Warm exact cache lookup | About 166 ns | Local microbenchmark; process-local lookup only |
| Speculative dispatch on the allow path | Waits only for the slower of the guardrails and the model, not both in turn | Eligible non-streaming requests; a denied request wastes one provider call |
| Embedded guard runtime | About 20–300 ms saved | No separate guard hop; depends on workload and deployment |
| Per-category guard timeouts | p99 tail latency about 30–50% lower | Example compared with one flat 1,500 ms timeout |
Method and context: performance overview in the docs. The docs also publish cache fixture results with their own conditions. Results depend on your policies, models, hardware and network: to reproduce them, run representative traffic with the policies, models and logging settings you will use in production, measure tail latency as well as averages, and share what you find through the repository.
Start here
Check the licence before you build on the core, and follow releases in the changelog: the server and the Python SDK share one version number.
Repository and licence
Source code, README and the Apache License 2.0 text, in one public repository on GitHub.
View the repository
Changelog
Release notes for the server and the Python SDK; the current release is 3.2.3.
Read the changelog
Contribute
Start with the README, then raise issues or propose changes in the repository.
Contribute on GitHub
Read the code, then run it
Inspect the open-source core on GitHub, or start on the managed cloud with the free Developer plan.