Quick start guide

# ~/.continue/config.yaml
models:
  - name: TokenCompress - DeepSeek
    provider: openai
    model: deepseek-chat
    apiKey: ak_live_xxx...xxx::sk-your-provider-key
    apiBase: https://tokencompress.com/v1/deepseek
    roles:
      - chat
      - edit
      - apply
    defaultCompletionOptions:
      stream: true

import urllib.request
from langchain_openai import ChatOpenAI

# Point LangChain at the TokenCompress proxy
llm = ChatOpenAI(
    base_url="https://tokencompress.com/v1/anthropic",
    api_key="ak_live_xxx...xxx::sk-ant-your-anthropic-key",
    model="claude-sonnet-4-20250514",
)

# Download a large open-source Rust file (3,000+ lines)
url = "https://raw.githubusercontent.com/dani-garcia/" \
      "vaultwarden/main/src/api/core/organizations.rs"
org_rs = urllib.request.urlopen(url).read().decode()

# Ask about a specific function — TokenCompress compresses
# the code context automatically before forwarding to Anthropic
response = llm.invoke(
    f"""Here is the file organizations.rs:

```rust
{org_rs}
```

What does post_groups do if org_groups_enabled() returns false?"""
)
print(response.content)

import urllib.request
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langgraph.graph import StateGraph, MessagesState, END

llm = ChatOpenAI(
    base_url="https://tokencompress.com/v1/anthropic",
    api_key="ak_live_xxx...xxx::sk-ant-your-anthropic-key",
    model="claude-sonnet-4-20250514",
)

# Download a large Rust file from Vaultwarden
url = "https://raw.githubusercontent.com/dani-garcia/" \
      "vaultwarden/main/src/api/core/organizations.rs"
org_rs = urllib.request.urlopen(url).read().decode()

# Step 1: Identify security-sensitive functions
def find_sensitive(state: MessagesState):
    return {"messages": [llm.invoke(state["messages"])]}

# Step 2: Review those functions for vulnerabilities
def review_security(state: MessagesState):
    followup = HumanMessage(
        content="Now review the functions you identified for "
                "authorization bypasses or injection vulnerabilities."
    )
    return {"messages": [llm.invoke(state["messages"] + [followup])]}

graph = StateGraph(MessagesState)
graph.add_node("find_sensitive", find_sensitive)
graph.add_node("review_security", review_security)
graph.set_entry_point("find_sensitive")
graph.add_edge("find_sensitive", "review_security")
graph.add_edge("review_security", END)
app = graph.compile()

# Run the agent — TokenCompress compresses at every step
result = app.invoke({"messages": [
    SystemMessage(content="You are a security auditor."),
    HumanMessage(content=f"""Review this Rust file:

```rust
{org_rs}
```

List all functions that handle authentication or authorization."""),
]})
print(result["messages"][-1].content)

# ~/.codex/config.toml
model = "claude-haiku-4-5-20251001"
model_reasoning_effort = "medium"
openai_base_url = "https://tokencompress.com/v1/anthropic"
openai_api_key = "ak_live_xxx...xxx::sk-ant-your-anthropic-key"

# ~/.codex/config.toml — full example
model = "claude-haiku-4-5-20251001"
model_reasoning_effort = "medium"
service_tier = "fast"
openai_base_url = "https://tokencompress.com/v1/anthropic"
openai_api_key = "ak_live_xxx...xxx::sk-ant-your-anthropic-key"

# Trust your project directories
[projects.'~/my-project']
trust_level = "trusted"

# Windows: use elevated sandbox
[windows]
sandbox = "elevated"

# Clone Vaultwarden and ask Codex to analyze it
$ git clone https://github.com/dani-garcia/vaultwarden.git
$ cd vaultwarden
$ codex "Read src/api/core/organizations.rs and explain what post_groups does if org_groups_enabled() returns false"

import urllib.request
from openai import OpenAI

client = OpenAI(
    base_url="https://tokencompress.com/v1/anthropic",
    api_key="ak_live_xxx...xxx::sk-ant-your-anthropic-key",
)

# Download Vaultwarden organizations.rs (3,000+ lines of Rust)
url = "https://raw.githubusercontent.com/dani-garcia/" \
      "vaultwarden/main/src/api/core/organizations.rs"
org_rs = urllib.request.urlopen(url).read().decode()

# TokenCompress compresses the code, then forwards to Anthropic
response = client.chat.completions.create(
    model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": f"""
```rust
{org_rs}
```
What does post_groups do if org_groups_enabled() returns false?"""}],
)
print(response.choices[0].message.content)

// Install Claude Code
$ npm install -g @anthropic-ai/claude-code

$ cd my-project
$ claude "Read src/main.rs and explain what it does"

// ~/.openclaw/config.json
{
  "providers": {
    "openai": {
      "baseUrl": "https://tokencompress.com/v1/openai",
      "apiKey": "ak_live_xxx...xxx::sk-your-openai-key",
      "models": ["gpt-4o", "o3-mini"]
    }
  }
}

// ~/.openclaw/config.json
{
  "providers": {
    "anthropic": {
      "baseUrl": "https://tokencompress.com/v1/anthropic",
      "apiKey": "ak_live_xxx...xxx::sk-ant-your-anthropic-key",
      "models": ["claude-sonnet-4-20250514"]
    }
  }
}