LangCache Terminal

█ LangCache Gateway v1.0.0

> Semantic caching for LLM APIs

 ╦  ╔═╗╔╗╔╔═╗╔═╗╔═╗╔═╗╦ ╦╔═╗
║  ╠═╣║║║║ ╦║  ╠═╣║  ╠═╣║╣
 ╩═╝╩ ╩╝╚╝╚═╝╚═╝╩ ╩╚═╝╩ ╩╚═╝

user@langcache:~$ cat welcome.txt

Welcome to LangCache Gateway.

A semantic caching layer for OpenAI, Anthropic, and Google Gemini APIs.

Features:

• Vector-based semantic similarity matching

• Statistics over prompt usage and caching

• Support for streaming and non-streaming requests

• Drop in replacement for OpenAI, Anthropic, and Gemini

── Authenticate to get started ──

user@langcache:~$ whoami

user@langcache:~$ ls workspaces

Your workspaces:

user@langcache:~$ cat integration-guide.md

── Integration Examples ──

openai-example.sh

curl -X POST https://gateway.langcache.io/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "x-langcache-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "messages": [
      {"role": "user", "content": "Hello!"}
    ]
  }'

openai_example.py

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url="https://gateway.langcache.io/v1"
)

response = client.responses.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "Hello!"}
    ],
    extra_headers={
        "x-langcache-key": "YOUR_API_KEY"
    }
)

print(response.choices[0].message.content)

openai-example.js

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: 'https://gateway.langcache.io/v1'
});

const response = await client.responses.create({
  model: 'gpt-4',
  messages: [
    { role: 'user', content: 'Hello!' }
  ]
}, {
  headers: {
    'x-langcache-key': 'YOUR_API_KEY'
  }
});

console.log(response.choices[0].message.content);

anthropic-example.sh

curl -X POST https://gateway.langcache.io/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "x-langcache-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, Claude!"}
    ]
  }'

anthropic_example.py

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    base_url="https://gateway.langcache.io/v1"
)

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ],
    extra_headers={
        "x-langcache-key": "YOUR_API_KEY"
    }
)

print(message.content[0].text)

anthropic-example.js

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: 'https://gateway.langcache.io/v1'
});

const message = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, Claude!' }
  ]
}, {
  headers: {
    'x-langcache-key': 'YOUR_API_KEY'
  }
});

console.log(message.content[0].text);

gemini-example.sh

curl -X POST "https://gateway.langcache.io/v1beta/models/gemini-2.5-flash:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "x-langcache-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "parts": [
          {
            "text": "Hello, Gemini!"
          }
        ]
      }
    ]
  }'

gemini_example.py

import os
import google.generativeai as genai

# Configure the Gemini client to use LangCache Gateway
genai.configure(
    api_key=os.getenv("GEMINI_API_KEY"),
    transport="rest",
    client_options={
        "api_endpoint": "https://gateway.langcache.io/v1beta"
    }
)

model = genai.GenerativeModel('gemini-2.5-flash')

# Add LangCache API key header
response = model.generate_content(
    "Hello, Gemini!",
    request_options={
        "headers": {
            "x-langcache-key": "YOUR_API_KEY"
        }
    }
)

print(response.text)

gemini-example.js

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI(
  process.env.GEMINI_API_KEY,
  {
    baseUrl: 'https://gateway.langcache.io/v1beta'
  }
);

const model = genAI.getGenerativeModel({
  model: 'gemini-2.5-flash'
});

const result = await model.generateContent(
  'Hello, Gemini!',
  {
    headers: {
      'x-langcache-key': 'YOUR_API_KEY'
    }
  }
);

const response = await result.response;
console.log(response.text());

user@langcache:~$ ./display-stats

── Usage Statistics ──

Cache Performance

Token Usage

Bandwidth Usage

user@langcache:~$ ./show-top-cache-hits

── Top 10 Cache Hits ──

user@langcache:~$ cat config/similarity.conf

user@langcache:~$ ./manage-api-keys

── API Key Management ──

Create and manage API keys for secure workspace access.

user@langcache:~$ ./subscription-status

── Your Subscription ──

Cache Hit Details

Create New API Key

API Key Created Successfully

Privacy Policy

1. Information We Collect

2. How We Use Your Information

3. Data Security

4. Data Retention

5. Your Rights

6. Third-Party Services

7. Contact Us

Terms of Service

1. Acceptance of Terms

2. Description of Service

3. Account Registration

4. Acceptable Use

5. API Keys and Authentication

6. Service Availability

7. Billing and Payments

8. Data and Privacy

9. Intellectual Property

10. Limitation of Liability

11. Termination

12. Changes to Terms

13. Contact Information