GeneralCompute

https://docs.generalcompute.com
Admin
GeneralCompute provides OpenAI-compatible SDKs for Node.js and Python, offering a drop-in...
Tokens:21,361
Snippets:170
Trust Score:7.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Clone Example Project

Source: https://docs.generalcompute.com/examples/node-streaming

Clone the full example project from GitHub to get started.

```bash
git clone https://github.com/generalcompute/docs
cd docs/examples/node-streaming
npm install
```

--------------------------------

### Install Node.js SDK

Source: https://docs.generalcompute.com/quickstart

Install the General Compute SDK for Node.js using npm.

```bash
npm install @generalcompute/sdk
```

--------------------------------

### Set Up Node.js Project

Source: https://docs.generalcompute.com/examples/node-streaming

Initialize a new Node.js project and install the General Compute SDK.

```bash
mkdir my-chat && cd my-chat
npm init -y
npm install @generalcompute/sdk
```

--------------------------------

### Install Python SDK

Source: https://docs.generalcompute.com/quickstart

Install the General Compute SDK for Python using pip.

```bash
pip install generalcompute
```

--------------------------------

### Run the Development Server

Source: https://docs.generalcompute.com/examples/vercel-ai-chat

Start the Next.js development server to run your chat application locally.

```bash
npm run dev
```

--------------------------------

### Start opencode Session with General Compute Model

Source: https://docs.generalcompute.com/opencode

Initiate an opencode session using a General Compute model. Ensure your auth.json is updated prior to starting a new session.

```bash
opencode -m general-compute/minimax-m2.7
```

```bash
opencode -m minimax-m2.7
```

--------------------------------

### Install Dependencies for Next.js Chat App

Source: https://docs.generalcompute.com/examples/vercel-ai-chat

Install Next.js and the necessary AI SDK packages for your chat application.

```bash
npx create-next-app@latest my-chat-app
cd my-chat-app
npm install ai @ai-sdk/openai-compatible @ai-sdk/react
```

--------------------------------

### Agent Signup Verification Response

Source: https://docs.generalcompute.com/agent-signup

Upon successful verification, the response includes the API key, organization ID, user ID, and links to documentation and quickstart guides. The API key is only shown once.

```json
{
  "status": "completed",
  "apiKey": "gc_abcd1234...",
  "organizationId": "org-uuid",
  "userId": "user-uuid",
  "docs": "https://docs.generalcompute.com",
  "quickstart": {
    "curl": "curl -X POST https://api.generalcompute.com/v1/chat/completions -H 'Authorization: Bearer gc_abcd1234...' -H 'Content-Type: application/json' -d '{\"model\": \"minimax-m2.7\", \"messages\": [{\"role\": \"user\", \"content\": \"Hello!\"}]}'",
    "note": "General Compute is OpenAI-compatible — use any OpenAI SDK by setting the base URL to https://api.generalcompute.com/v1"
  }
}
```

--------------------------------

### Vercel AI SDK: Create OpenAI-Compatible Provider

Source: https://docs.generalcompute.com/migrate-with-ai

Use this to create a General Compute provider for the Vercel AI SDK. Ensure you have installed the `@ai-sdk/openai-compatible` package.

```javascript
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";

const generalcompute = createOpenAICompatible({
  name: "generalcompute",
  baseURL: "https://api.generalcompute.com/v1",
  headers: {
    Authorization: `Bearer ${process.env.GENERALCOMPUTE_API_KEY}`,
  },
});

// Then use generalcompute("minimax-m2.7") wherever you previously passed a model.
```

--------------------------------

### Rate Limit Headers Example

Source: https://docs.generalcompute.com/rate-limits

These headers are included in every API response to help track your usage against rate limits.

```text
x-ratelimit-limit-requests: 300
x-ratelimit-remaining-requests: 299
x-ratelimit-reset-requests: 2024-01-01T00:00:00Z
```

--------------------------------

### Configure General Compute Provider in OpenClaw

Source: https://docs.generalcompute.com/openclaw

Paste this JSON block into your openclaw.json for a fresh setup. Replace 'gc_your_api_key' with your actual API key obtained from General Compute.

```json
{
  agents: {
    defaults: {
      model: {
        primary: "generalcompute/minimax-m2.7",
        fallbacks: [
          "generalcompute/deepseek-v3.2",
          "generalcompute/deepseek-v3.1",
        ],
      },
    },
  },
  models: {
    mode: "merge",
    providers: {
      generalcompute: {
        api: "openai-completions",
        baseUrl: "https://api.generalcompute.com/v1",
        apiKey: "gc_your_api_key",
        models: {
          "minimax-m2.7": { contextWindow: 160000 },
          "deepseek-v3.2": { contextWindow: 32000 },
          "deepseek-v3.1": { contextWindow: 128000 },
        },
      },
    },
  },
}
```

--------------------------------

### List Models for Organization

Source: https://docs.generalcompute.com/api-reference/introduction

Retrieve a list of models enabled for your organization, including private checkpoints. This is an alternative to OpenAI's `GET /v1/models`.

```bash
curl https://api.generalcompute.com/v1/models/list \
  -H "Authorization: Bearer $GENERALCOMPUTE_API_KEY"
```

--------------------------------

### POST /v1/models/list

Source: https://docs.generalcompute.com/api-reference/introduction

Returns the models enabled for your organization, including private checkpoints. This endpoint should be used instead of OpenAI’s `GET /v1/models`.

```APIDOC
## POST /v1/models/list

### Description
Returns the models enabled for your organization (including private checkpoints). Use this instead of OpenAI’s `GET /v1/models`.

### Method
POST

### Endpoint
/v1/models/list

### Parameters
#### Request Body
This endpoint does not require a request body.

### Request Example
```bash
curl https://api.generalcompute.com/v1/models/list \
  -H "Authorization: Bearer $GENERALCOMPUTE_API_KEY"
```

### Response
#### Success Response (200)
- **data** (array) - An array of model objects.
  - **id** (string) - The ID of the model.
  - **created** (integer) - The creation timestamp of the model.
  - **owned_by** (string) - The organization that owns the model.

#### Response Example
```json
{
  "data": [
    {
      "id": "minimax-m2.7",
      "created": 1677610602,
      "owned_by": "organization-id"
    }
  ]
}
```
```

--------------------------------

### Step 1: Initiate Signup

Source: https://docs.generalcompute.com/agent-signup

Initiates the signup process by sending the user's email address. It returns a signup ID and verification details. No authentication is required.

```APIDOC
## POST /v1/public/agent-signups

### Description
Initiates the agent signup process.

### Method
POST

### Endpoint
https://api.generalcompute.com/v1/public/agent-signups

### Parameters
#### Request Body
- **email** (string) - Required - The user's email address

### Request Example
```json
{
  "email": "user@example.com"
}
```

### Response
#### Success Response (201)
- **signupId** (string) - The ID for the signup process.
- **verificationChannel** (string) - The channel used for verification (e.g., "email").
- **destination** (string) - The destination for the verification code (e.g., masked email).
- **expiresAt** (string) - The expiration time for the verification code in ISO 8601 format.

#### Response Example
```json
{
  "signupId": "abc-123",
  "verificationChannel": "email",
  "destination": "us***@example.com",
  "expiresAt": "2025-01-01T00:15:00Z"
}
```
```

--------------------------------

### Instantiate GeneralCompute Client with API Key (Python)

Source: https://docs.generalcompute.com/api-keys

Initialize the GeneralCompute client in Python, retrieving the API key from environment variables. Ensure the GENERALCOMPUTE_API_KEY environment variable is set.

```python
import os
client = GeneralCompute(api_key=os.getenv("GENERALCOMPUTE_API_KEY"))
```

--------------------------------

### Initiate Agent Signup

Source: https://docs.generalcompute.com/agent-signup

Send a POST request to initiate the signup process for a user's email address. Save the returned signupId for the next step. The verification code expires in 15 minutes.

```bash
curl -X POST https://api.generalcompute.com/v1/public/agent-signups \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'
```

--------------------------------

### Instantiate GeneralCompute Client with API Key (Node.js)

Source: https://docs.generalcompute.com/api-keys

Initialize the GeneralCompute client in Node.js, retrieving the API key from environment variables. Ensure the GENERALCOMPUTE_API_KEY environment variable is set.

```typescript
const client = new GeneralCompute({
  apiKey: process.env.GENERALCOMPUTE_API_KEY,
});
```

--------------------------------

### Add General Compute API Key

Source: https://docs.generalcompute.com/examples/vercel-ai-chat

Configure your General Compute API key by creating a `.env.local` file in your project's root directory.

```bash
GENERALCOMPUTE_API_KEY=gc_your_api_key_here
```

--------------------------------

### Instantiate OpenAI Client with GeneralCompute Base URL (Python)

Source: https://docs.generalcompute.com/api-keys

Configure an OpenAI client in Python to use GeneralCompute's production API. Set both the API key and the base_url. The base_url should point to `https://api.generalcompute.com/v1`.

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("GENERALCOMPUTE_API_KEY"),
    base_url="https://api.generalcompute.com/v1",
)
```

--------------------------------

### Instantiate OpenAI Client with GeneralCompute Base URL (Node.js)

Source: https://docs.generalcompute.com/api-keys

Configure an OpenAI client in Node.js to use GeneralCompute's production API. Set both the API key and the baseURL. The baseURL should point to `https://api.generalcompute.com/v1`.

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.GENERALCOMPUTE_API_KEY,
  baseURL: "https://api.generalcompute.com/v1",
});
```

--------------------------------

### OpenAPI Specification for Public Models

Source: https://docs.generalcompute.com/api-reference/endpoints/public-models

This OpenAPI 3.1.0 specification defines the GET /v1/public/models endpoint. It outlines the request, responses, and schema for retrieving public model metadata.

```yaml
GET /v1/public/models
openapi: 3.1.0
info:
  title: GeneralCompute API
  version: 1.0.0
  description: OpenAI-compatible API surface for the GeneralCompute inference platform.
  contact:
    name: GeneralCompute
    url: https://www.generalcompute.com
servers:
  - url: https://api.generalcompute.com
    description: Production
  - url: http://localhost:3000
    description: Local
security: []
paths:
  /v1/public/models:
    get:
      tags:
        - Public
      summary: List public models
      description: >-
        Public endpoint that returns the metadata for the models surfaced in
        docs and pricing pages.
      responses:
        '200':
          description: List of model metadata objects
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicModelsResponse'
components:
  schemas:
    PublicModelsResponse:
      type: object
      properties:
        object:
          type: string
          enum:
            - list
        data:
          type: array
          items:
            type: object
            properties:
              modelId:
                type: string
              displayName:
                type: string
              supportsReasoning:
                type: boolean
              supportsVision:
                type: boolean
              maxTokens:
                type:
                  - number
                  - 'null'
            required:
              - modelId
              - displayName
              - supportsReasoning
              - supportsVision
              - maxTokens
      required:
        - object
        - data

```

--------------------------------

### Migrate OpenAI SDK to General Compute

Source: https://docs.generalcompute.com/migrate-with-ai

Use this prompt with AI agents to migrate from the OpenAI SDK to General Compute. General Compute acts as a drop-in replacement, requiring only changes to the client constructor's base URL and API key, model name updates, and environment variable configuration.

```text
Migrate this project from OpenAI to General Compute. General Compute is a drop-in replacement — keep using the OpenAI SDK, just point it at General Compute.

1. Change the base URL and API key in the client constructor:
   - Node.js: new OpenAI({ baseURL: "https://api.generalcompute.com/v1", apiKey: process.env.GENERALCOMPUTE_API_KEY })
   - Python: OpenAI(base_url="https://api.generalcompute.com/v1", api_key=os.getenv("GENERALCOMPUTE_API_KEY"))

2. Update model names:
   - gpt-4o, gpt-4, gpt-3.5-turbo → minimax-m2.7 (general purpose) or deepseek-v3.2 (reasoning)
   - See all models: https://docs.generalcompute.com/models

3. Update environment variables:
   - Add GENERALCOMPUTE_API_KEY to all .env files, CI configs, and deployment settings.

Everything else stays the same — imports, client.chat.completions.create(), streaming, tool calling, JSON mode, and all parameters work identically.

Docs: https://docs.generalcompute.com/quickstart
```

--------------------------------

### GET /v1/public/models

Source: https://docs.generalcompute.com/api-reference/introduction

An unauthenticated endpoint that powers the [Models & Pricing](/models) page. This feed can be used to keep marketing sites synchronized with the live catalog or to build in-product selectors that don’t rely on secrets.

```APIDOC
## GET /v1/public/models

### Description
Unauthenticated endpoint that powers the [Models & Pricing](/models) page. Use this feed to keep your marketing site synchronized with the live catalog or to build in-product selectors that don’t rely on secrets.

### Method
GET

### Endpoint
/v1/public/models

### Parameters
This endpoint does not require any parameters.

### Request Example
```bash
curl https://api.generalcompute.com/v1/public/models
```

### Response
#### Success Response (200)
- **data** (array) - An array of public model objects.
  - **id** (string) - The ID of the model.
  - **description** (string) - A description of the model.
  - **owned_by** (string) - The organization that owns the model.

#### Response Example
```json
{
  "data": [
    {
      "id": "gpt-3.5-turbo",
      "description": "A fast and capable model.",
      "owned_by": "openai"
    }
  ]
}
```
```

--------------------------------

### Python Chat Completion

Source: https://docs.generalcompute.com/quickstart

Initialize the General Compute client and create a chat completion in Python.

```python
from generalcompute import GeneralCompute

client = GeneralCompute()

response = client.chat.completions.create(
    model="minimax-m2.7",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
)

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

--------------------------------

### Migrate from OpenAI SDK to GeneralCompute (Python)

Source: https://docs.generalcompute.com/quickstart

This snippet demonstrates the equivalent migration from the OpenAI Python SDK to the GeneralCompute SDK. The core change involves updating the import statement and client initialization.

```python
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)

```

--------------------------------

### Create Chat Completions

Source: https://docs.generalcompute.com/api-reference/introduction

Use this endpoint to create chat completions. Set `stream` to `true` for streaming responses.

```bash
curl https://api.generalcompute.com/v1/chat/completions \
  -H "Authorization: Bearer $GENERALCOMPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "minimax-m2.7",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Summarize this paragraph"}
        ],
        "stream": false
      }'
```

--------------------------------

### Python Chat Completion

Source: https://docs.generalcompute.com/quickstart

Initialize the GeneralCompute SDK with your API key and create a chat completion.

```python
from generalcompute import GeneralCompute

client = GeneralCompute(api_key=os.getenv("GENERALCOMPUTE_API_KEY"))

response = client.chat.completions.create(
    model="minimax-m2.7",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

--------------------------------

### Migrate Anthropic SDK to General Compute

Source: https://docs.generalcompute.com/migrate-with-ai

Use this prompt with AI agents to migrate from the Anthropic SDK to the General Compute SDK. This involves replacing the SDK, updating the client constructor, modifying API calls to match OpenAI's structure, updating model names, and changing environment variables.

```text
Migrate this project from the Anthropic SDK to the General Compute SDK. General Compute uses an OpenAI-compatible API, so you'll replace the Anthropic SDK with @generalcompute/sdk (Node.js) or generalcompute (Python).

1. Replace the Anthropic SDK with the General Compute SDK:
   - Node.js: npm uninstall @anthropic-ai/sdk && npm install @generalcompute/sdk
   - Python: pip uninstall anthropic && pip install generalcompute

2. Replace the client constructor:
   - Node.js (before): import Anthropic from "@anthropic-ai/sdk"; const client = new Anthropic();
   - Node.js (after):  import GeneralCompute from "@generalcompute/sdk"; const client = new GeneralCompute();
   - Python (before):  from anthropic import Anthropic; client = Anthropic()
   - Python (after):   from generalcompute import GeneralCompute; client = GeneralCompute()

3. Replace all API calls — the method names and response shapes are different:
   - client.messages.create() → client.chat.completions.create()
   - message.content[0].text → completion.choices[0].message.content
   - max_tokens is optional on General Compute (not required like Anthropic)
   - system parameter → put system message as first item in messages array with role: "system"
   - Streaming: client.messages.stream() → client.chat.completions.create({ stream: true }), then iterate chunks with chunk.choices[0].delta.content
   - Tool use: Anthropic's tool_use/tool_result blocks → OpenAI-style tools array and tool_calls in responses

4. Update model names:
   - claude-sonnet-4-20250514, claude-opus-4-20250514, claude-haiku-3-5-20241022 → minimax-m2.7 (general purpose) or deepseek-v3.2 (reasoning)
   - See all models: https://docs.generalcompute.com/models

5. Update environment variables:
   - Replace ANTHROPIC_API_KEY with GENERALCOMPUTE_API_KEY in all .env files, CI configs, and deployment settings.

Docs: https://docs.generalcompute.com/quickstart
API reference: https://docs.generalcompute.com/api-reference/introduction
```

--------------------------------

### Node.js Chat Completion

Source: https://docs.generalcompute.com/quickstart

Initialize the GeneralCompute SDK with your API key and create a chat completion.

```typescript
import GeneralCompute from "@generalcompute/sdk";

const client = new GeneralCompute({
  apiKey: process.env.GENERALCOMPUTE_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "minimax-m2.7",
  messages: [{ role: "user", content: "Hello!" }],
});
```

--------------------------------

### Node.js Chat Completion

Source: https://docs.generalcompute.com/quickstart

Initialize the General Compute client and create a chat completion in Node.js.

```typescript
import GeneralCompute from "@generalcompute/sdk";

const client = new GeneralCompute();

const completion = await client.chat.completions.create({
  model: "minimax-m2.7",
  messages: [{ role: "user", content: "Hello!" }],
});

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

--------------------------------

### Migrate from OpenAI SDK to GeneralCompute (TypeScript)

Source: https://docs.generalcompute.com/quickstart

This snippet shows the minimal change required to switch from the OpenAI SDK to the GeneralCompute SDK in a TypeScript Node.js environment. It highlights the client instantiation and the chat completions API call.

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello!" }],
});

```

--------------------------------

### Use API Key with OpenAI SDK (Python)

Source: https://docs.generalcompute.com/agent-signup

Configure the OpenAI Python client to use General Compute by setting the `base_url` and `api_key`. This allows seamless integration with existing OpenAI-based applications.

```python
from openai import OpenAI

client = OpenAI(
    api_key="gc_abcd1234...",
    base_url="https://api.generalcompute.com/v1"
)

response = client.chat.completions.create(
    model="minimax-m2.7",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

--------------------------------

### Using Reasoning Models with GeneralCompute

Source: https://docs.generalcompute.com/features

This snippet shows how to use a reasoning-first model like 'deepseek-v3.2' for tasks requiring higher thinking timeouts. It sets a low temperature for more deterministic output.

```typescript
const completion = await client.chat.completions.create({
  model: "deepseek-v3.2",
  messages,
  temperature: 0.1,
  max_completion_tokens: 2048,
});
```

--------------------------------

### Verify Gateway Status and Check Logs

Source: https://docs.generalcompute.com/openclaw

After restarting the gateway, use these commands to confirm it's operational and to check for any errors in the gateway logs.

```bash
openclaw gateway status
tail -n 20 ~/.openclaw/logs/gateway.err.log
```

--------------------------------

### Create OpenAI-Compatible API Route

Source: https://docs.generalcompute.com/examples/vercel-ai-chat

Set up an API route in Next.js using `@ai-sdk/openai-compatible` to connect with General Compute's API. This route handles incoming messages and streams responses.

```typescript
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { streamText } from "ai";

const generalcompute = createOpenAICompatible({
  name: "generalcompute",
  baseURL: "https://api.generalcompute.com/v1",
  headers: {
    Authorization: `Bearer ${process.env.GENERALCOMPUTE_API_KEY}`,
  },
});

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: generalcompute("minimax-m2.7"),
    // Convert UI messages (parts format) to model messages (content format)
    messages: messages.map((m: { role: string; parts?: { type: string; text: string }[]; content?: string }) => ({
      role: m.role,
      content: m.parts
        ? m.parts.filter((p) => p.type === "text").map((p) => p.text).join("")
        : m.content,
    })),
  });

  return result.toUIMessageStreamResponse();
}
```

--------------------------------

### Configure OpenAI-Compatible Provider for General Compute

Source: https://docs.generalcompute.com/openclaw

When migrating from an OpenAI-compatible provider, update the `baseUrl` to General Compute's API endpoint and set your API key.

```json
{
  "api": "openai-completions",
  "baseUrl": "https://api.generalcompute.com/v1",
  "apiKey": "YOUR_GENERAL_COMPUTE_API_KEY"
}
```

--------------------------------

### Set General Compute API Key

Source: https://docs.generalcompute.com/quickstart

Configure your API key for General Compute by adding it to your .env.local file. This key is essential for authenticating your requests to the General Compute API.

```bash
GENERALCOMPUTE_API_KEY=gc_your_api_key_here

```

--------------------------------

### Readiness Probe

Source: https://docs.generalcompute.com/api-reference/openapi.json

Checks the readiness of the server to determine if it is ready to receive traffic.

```APIDOC
## GET /health/ready

### Description
Readiness probe to check if the server is ready to receive traffic.

### Method
GET

### Endpoint
/health/ready

### Response
#### Success Response (200)
- **description**: Server is ready to receive traffic

#### Response Example
```json
{
  "example": "{\"status\": \"ready\"}"
}
```

#### Error Response (503)
- **description**: One or more dependencies are unavailable

#### Response Example
```json
{
  "example": "{\"status\": \"unhealthy\", \"dependencies\": [\"database\"]}"
}
```
```

--------------------------------

### Agent Signup Initiation Response

Source: https://docs.generalcompute.com/agent-signup

The response contains the signupId, verification channel, destination email, and expiration time for the signup process.

```json
{
  "signupId": "abc-123",
  "verificationChannel": "email",
  "destination": "us***@example.com",
  "expiresAt": "2025-01-01T00:15:00Z"
}
```

--------------------------------

### Validate OpenClaw Configuration and List Models

Source: https://docs.generalcompute.com/openclaw

Run these commands after updating the configuration to ensure it's valid and to see the available models.

```bash
openclaw config validate
openclaw models list
```

--------------------------------

### Use API Key with OpenAI SDK (Node.js)

Source: https://docs.generalcompute.com/agent-signup

Configure the OpenAI Node.js client to use General Compute by setting the `baseURL` and `apiKey`. This enables easy migration from OpenAI or other compatible providers.

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "gc_abcd1234...",
  baseURL: "https://api.generalcompute.com/v1",
});

const response = await client.chat.completions.create({
  model: "minimax-m2.7",
  messages: [{ role: "user", content: "Hello!" }],
});
```

--------------------------------

### OpenAI-Compatible Client: Update Base URL and API Key

Source: https://docs.generalcompute.com/migrate-with-ai

Migrate any OpenAI-compatible client by changing the base URL to General Compute's endpoint and updating the API key environment variable.

```text
1. Change the base URL to: https://api.generalcompute.com/v1

2. Change the API key to use GENERALCOMPUTE_API_KEY instead of whatever provider key is currently set.
```

--------------------------------

### Set General Compute API Key

Source: https://docs.generalcompute.com/examples/node-streaming

Set your General Compute API key as an environment variable before running the application.

```bash
export GENERALCOMPUTE_API_KEY=gc_your_api_key_here
```

--------------------------------

### Find OpenClaw Configuration File Path

Source: https://docs.generalcompute.com/openclaw

Use this command to locate your OpenClaw configuration file. This is necessary before modifying the configuration.

```bash
openclaw config file
```

--------------------------------

### Step 2: Verify Email

Source: https://docs.generalcompute.com/agent-signup

Verifies the user's email address using a 6-digit code sent to their email. Upon successful verification, it returns an API key and other user details. No authentication is required.

```APIDOC
## POST /v1/public/agent-signups/{signupId}/verify

### Description
Verifies the email address provided during the signup process using a 6-digit code.

### Method
POST

### Endpoint
https://api.generalcompute.com/v1/public/agent-signups/{signupId}/verify

### Parameters
#### Path Parameters
- **signupId** (string) - Required - The ID obtained from the initiate signup step.
#### Request Body
- **code** (string) - Required - The 6-digit verification code sent to the user's email.

### Request Example
```json
{
  "code": "654321"
}
```

### Response
#### Success Response (200)
- **status** (string) - The status of the verification (e.g., "completed").
- **apiKey** (string) - The generated API key for the user. This is only shown once.
- **organizationId** (string) - The ID of the user's organization.
- **userId** (string) - The ID of the user.
- **docs** (string) - URL to the documentation.
- **quickstart** (object) - Quickstart information for using the API key.
  - **curl** (string) - Example cURL command.
  - **note** (string) - Note on OpenAI compatibility.

#### Response Example
```json
{
  "status": "completed",
  "apiKey": "gc_abcd1234...",
  "organizationId": "org-uuid",
  "userId": "user-uuid",
  "docs": "https://docs.generalcompute.com",
  "quickstart": {
    "curl": "curl -X POST https://api.generalcompute.com/v1/chat/completions -H 'Authorization: Bearer gc_abcd1234...' -H 'Content-Type: application/json' -d '{\"model\": \"minimax-m2.7\", \"messages\": [{\"role\": \"user\", \"content\": \"Hello!\"}]}'",
    "note": "General Compute is OpenAI-compatible — use any OpenAI SDK by setting the base URL to https://api.generalcompute.com/v1"
  }
}
```
```

--------------------------------

### Set API Key as Environment Variable

Source: https://docs.generalcompute.com/api-keys

Store your API key as an environment variable for automatic pickup by SDKs and CLIs. This is the recommended way to manage your API key.

```bash
export GENERALCOMPUTE_API_KEY=gc_live_your_api_key
```

--------------------------------

### List Models

Source: https://docs.generalcompute.com/api-reference/openapi.json

Retrieves a list of available models that can be used for various tasks.

```APIDOC
## GET /v1/models

### Description
Lists the models available for use. This endpoint provides details about each model, including its ID, object type, creation time, and ownership.

### Method
GET

### Endpoint
/v1/models

### Response
#### Success Response (200)
- **object** (string) - The type of object, always 'list'.
- **data** (array) - An array of model objects.
  - **id** (string) - The unique identifier for the model.
  - **object** (string) - The type of object, always 'model'.
  - **created** (number) - Unix timestamp of when the model was created.
  - **owned_by** (string) - The entity that owns the model.

#### Response Example
{
  "object": "list",
  "data": [
    {
      "id": "gpt-3.5-turbo",
      "object": "model",
      "created": 1677610602,
      "owned_by": "openai"
    }
  ]
}
```

--------------------------------

### POST /v1/chat/completions

Source: https://docs.generalcompute.com/api-reference/introduction

Create chat completions with optional streaming. The request body mirrors OpenAI’s schema, including tool calling and JSON mode fields. Streaming is enabled by setting `"stream": true` and returns `chat.completion.chunk` events over `text/event-stream`.

```APIDOC
## POST /v1/chat/completions

### Description
Create chat completions with optional streaming. The body mirrors OpenAI’s schema, including tool calling and JSON mode fields.

### Method
POST

### Endpoint
/v1/chat/completions

### Request Body
- **model** (string) - Required - The model to use for chat completions.
- **messages** (array) - Required - An array of message objects representing the conversation history.
  - **role** (string) - Required - The role of the message sender (e.g., "system", "user", "assistant").
  - **content** (string) - Required - The content of the message.
- **stream** (boolean) - Optional - Whether to stream the response. Defaults to false.

### Request Example
```json
{
  "model": "minimax-m2.7",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Summarize this paragraph"}
  ],
  "stream": false
}
```

### Response
#### Success Response (200)
- **id** (string) - The ID of the completion.
- **choices** (array) - An array of completion choices.
  - **message** (object) - The message content.
    - **role** (string) - The role of the message sender.
    - **content** (string) - The content of the message.
- **usage** (object) - Information about token usage.

#### Response Example
```json
{
  "id": "chatcmpl-123",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "This is a summary."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 5,
    "total_tokens": 15
  }
}
```
```

--------------------------------

### Liveness Probe

Source: https://docs.generalcompute.com/api-reference/openapi.json

Checks the liveness of the server to determine if it is running.

```APIDOC
## GET /health

### Description
Liveness probe to check if the server is running.

### Method
GET

### Endpoint
/health

### Response
#### Success Response (200)
- **description**: Server is running

#### Response Example
```json
{
  "example": "{\"status\": \"running\"}"
}
```
```

--------------------------------

### Configure OpenClaw Gateway with General Compute API Key

Source: https://docs.generalcompute.com/openclaw

Update your OpenClaw configuration file (openclaw.json) to use General Compute for inference. Ensure the API key is pasted as a literal value.

```json
{
  "providers": {
    "generalcompute": {
      "apiKey": "YOUR_GENERAL_COMPUTE_API_KEY"
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "generalcompute/minimax-m2.7"
      }
    }
  }
}
```

--------------------------------

### Python Streaming Chat Completion

Source: https://docs.generalcompute.com/quickstart

Enable streaming for chat completions in Python to receive real-time output.

```python
from generalcompute import GeneralCompute

client = GeneralCompute()

stream = client.chat.completions.create(
    model="minimax-m2.7",
    messages=[
        {"role": "user", "content": "Write a short poem"}
    ],
    stream=True,
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
```

--------------------------------

### List Public Models

Source: https://docs.generalcompute.com/api-reference/endpoints/public-models

Fetches the metadata for all models that are surfaced in the documentation and pricing pages. This endpoint is public and does not require authentication.

```APIDOC
## GET /v1/public/models

### Description
Public endpoint that returns the metadata for the models surfaced in docs and pricing pages.

### Method
GET

### Endpoint
/v1/public/models

### Parameters

### Request Example
(No request body for GET request)

### Response
#### Success Response (200)
- **object** (string) - Enum value: "list"
- **data** (array) - An array of model metadata objects.
  - **modelId** (string) - The unique identifier for the model.
  - **displayName** (string) - The human-readable name of the model.
  - **supportsReasoning** (boolean) - Indicates if the model supports reasoning capabilities.
  - **supportsVision** (boolean) - Indicates if the model supports vision capabilities.
  - **maxTokens** (number | null) - The maximum number of tokens the model can process.

#### Response Example
{
  "object": "list",
  "data": [
    {
      "modelId": "model-1",
      "displayName": "Model One",
      "supportsReasoning": true,
      "supportsVision": false,
      "maxTokens": 4096
    },
    {
      "modelId": "model-2",
      "displayName": "Model Two",
      "supportsReasoning": false,
      "supportsVision": true,
      "maxTokens": null
    }
  ]
}
```

--------------------------------

### Node.js Streaming Chat Loop

Source: https://docs.generalcompute.com/examples/node-streaming

Implement a multi-turn chat that streams responses token-by-token. This code requires the '@generalcompute/sdk' and 'readline' modules. It uses the 'minimax-m2.7' model by default.

```typescript
import GeneralCompute from "@generalcompute/sdk";
import * as readline from "readline";

const client = new GeneralCompute();

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const messages: { role: "system" | "user" | "assistant"; content: string }[] = [
  { role: "system", content: "You are a helpful assistant." },
];

async function chat(userMessage: string) {
  messages.push({ role: "user", content: userMessage });

  const stream = await client.chat.completions.create({
    model: "minimax-m2.7",
    messages,
    stream: true,
  });

  let assistantMessage = "";

  process.stdout.write("\nAssistant: ");
  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
      assistantMessage += content;
    }
  }
  console.log("\n");

  messages.push({ role: "assistant", content: assistantMessage });
}

function prompt() {
  rl.question("You: ", async (input) => {
    if (input.toLowerCase() === "exit") {
      rl.close();
      return;
    }
    await chat(input);
    prompt();
  });
}

console.log('Chat with General Compute (type "exit" to quit)\n');
prompt();

```

--------------------------------

### Update General Compute API Key via CLI

Source: https://docs.generalcompute.com/openclaw

Use this command to update only the API key for the General Compute provider if it's already configured. This shortcut does not set other necessary parameters like baseUrl or api.

```bash
openclaw config set models.providers.generalcompute.apiKey gc_your_api_key
```

--------------------------------

### List Public Models

Source: https://docs.generalcompute.com/api-reference/openapi.json

Retrieves a list of publicly available models with their capabilities.

```APIDOC
## GET /v1/public-models

### Description
Lists publicly available models, including their display names, reasoning and vision support, and maximum token limits.

### Method
GET

### Endpoint
/v1/public-models

### Response
#### Success Response (200)
- **object** (string) - The type of object, always 'list'.
- **data** (array) - An array of public model objects.
  - **modelId** (string) - The unique identifier for the model.
  - **displayName** (string) - A user-friendly display name for the model.
  - **supportsReasoning** (boolean) - Indicates if the model supports reasoning capabilities.
  - **supportsVision** (boolean) - Indicates if the model supports vision capabilities.
  - **maxTokens** (number | null) - The maximum number of tokens the model can process.

#### Response Example
{
  "object": "list",
  "data": [
    {
      "modelId": "claude-3-opus-20240229",
      "displayName": "Claude 3 Opus",
      "supportsReasoning": true,
      "supportsVision": true,
      "maxTokens": 200000
    }
  ]
}
```

--------------------------------

### Tool Calling and JSON Mode with GeneralCompute

Source: https://docs.generalcompute.com/features

This snippet demonstrates how to use tool calling and JSON mode with the GeneralCompute client. It defines a 'get_weather' function and sets the response format to JSON.

```typescript
const completion = await client.chat.completions.create({
  model: "deepseek-v3.2",
  messages,
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Look up the weather for a city",
        parameters: {
          type: "object",
          properties: { location: { type: "string" } },
          required: ["location"],
        },
      },
    },
  ],
  response_format: { type: "json_object" }, // JSON mode
});
```

--------------------------------

### Monitor OpenClaw Gateway Logs

Source: https://docs.generalcompute.com/openclaw

Tail the gateway error log to check for any issues during inference or startup. A clean log indicates successful operation.

```bash
tail ~/.openclaw/logs/gateway.err.log
```

--------------------------------

### Validate OpenClaw Configuration

Source: https://docs.generalcompute.com/openclaw

Run this command to confirm that your OpenClaw configuration file parses correctly after making changes.

```bash
openclaw config validate
```

--------------------------------

### Chat Completions

Source: https://docs.generalcompute.com/llms.txt

Provides OpenAI-compatible chat completion endpoint with streaming support.

```APIDOC
## POST /v1/chat/completions

### Description
Generates chat completions for a given prompt using an OpenAI-compatible API. Supports streaming responses.

### Method
POST

### Endpoint
/v1/chat/completions

### Parameters
#### Request Body
- **model** (string) - Required - The model to use for chat completions.
- **messages** (array) - Required - A list of messages comprising the conversation.
- **stream** (boolean) - Optional - Whether to stream back partial message deltas as they become available.

### Request Example
{
  "model": "gpt-3.5-turbo",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Who won the world series in 2020?"}
  ],
  "stream": false
}

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the completion.
- **object** (string) - Type of object returned, e.g., `chat.completion`.
- **created** (integer) - Unix timestamp of when the completion was created.
- **model** (string) - The model used for the completion.
- **choices** (array) - A list of completion choices.
  - **index** (integer) - Index of the choice.
  - **message** (object) - The generated message.
    - **role** (string) - Role of the author, e.g., `assistant`.
    - **content** (string) - The content of the message.
  - **finish_reason** (string) - The reason the model stopped generating tokens.
- **usage** (object) - Usage statistics for the completion.
  - **prompt_tokens** (integer) - Number of tokens in the prompt.
  - **completion_tokens** (integer) - Number of tokens in the completion.
  - **total_tokens** (integer) - Total tokens used.

#### Response Example
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-3.5-turbo-0613",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The Los Angeles Dodgers won the World Series in 2020."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 15,
    "total_tokens": 25
  }
}
```

--------------------------------

### POST /v1/chat/completions

Source: https://docs.generalcompute.com/api-reference/endpoints/chat-completions

Creates a chat completion based on the provided messages and model. Supports streaming responses.

```APIDOC
## POST /v1/chat/completions

### Description
Creates a chat completion based on the provided messages and model. Supports streaming responses.

### Method
POST

### Endpoint
/v1/chat/completions

### Parameters
#### Request Body
- **model** (string) - Required - The model to use for chat completion.
- **messages** (array) - Required - An array of message objects representing the conversation history.
  - **role** (string) - Required - The role of the author of the message (e.g., system, user, assistant).
  - **content** (string | array | null) - Optional - The content of the message.
  - **name** (string) - Optional - The name of the author of the message.
  - **function_call** (object) - Optional - Represents a function call.
  - **tool_calls** (object) - Optional - Represents tool calls.
- **temperature** (number) - Optional - Controls randomness. Lower values make output more focused and deterministic.
- **top_p** (number) - Optional - Controls diversity via nucleus sampling.
- **n** (integer) - Optional - How many chat completion choices to generate for each input message.
- **stream** (boolean) - Optional - Whether to stream back partial message deltas as they are generated.
- **stop** (string | array) - Optional - A maximum of 4 sequences where the API will stop generating further tokens.
- **max_tokens** (integer) - Optional - The maximum number of tokens to generate in the completion.
- **presence_penalty** (number) - Optional - Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far.
- **frequency_penalty** (number) - Optional - Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far.
- **logit_bias** (object) - Optional - Modifies the likelihood of specified tokens appearing in the completion.
- **user** (string) - Optional - A unique identifier representing your end-user.
- **top_k** (number) - Optional - Controls diversity via top-k sampling.
- **repetition_penalty** (number) - Optional - Controls repetition.

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the completion.
- **object** (string) - Type of object returned, e.g., `chat.completion`.
- **created** (number) - Unix timestamp of when the completion was created.
- **model** (string) - The model used for the completion.
- **choices** (array) - An array of completion choices.
  - **index** (number) - Index of the choice.
  - **message** (object) - The message content.
    - **role** (string) - The role of the author.
    - **content** (string | null) - The content of the message.
    - **function_call** (object) - Function call details.
    - **tool_calls** (object) - Tool call details.
  - **finish_reason** (string | null) - The reason the model stopped generating tokens.
  - **logprobs** (object) - Log probability information.
- **usage** (object) - Usage statistics for the completion.
  - **prompt_tokens** (number) - Number of tokens in the prompt.
  - **completion_tokens** (number) - Number of tokens in the completion.
  - **total_tokens** (number) - Total tokens used.
- **system_fingerprint** (string) - System fingerprint.

#### Success Response (200) - Streaming
- **id** (string) - Unique identifier for the completion.
- **object** (string) - Type of object returned, e.g., `chat.completion.chunk`.
- **created** (number) - Unix timestamp of when the chunk was created.
- **choices** (array) - An array of completion chunk choices.
  - **index** (number) - Index of the choice.
  - **delta** (object) - The delta content.
    - **role** (string) - The role of the author.
    - **content** (string) - The content of the message chunk.
    - **function_call** (object) - Function call details.
    - **tool_calls** (object) - Tool call details.
  - **finish_reason** (string | null) - The reason the model stopped generating tokens.
  - **logprobs** (object) - Log probability information.

#### Error Response (400)
- **description**: Invalid request.
- **content**: application/json schema referencing `OpenAIError`.

#### Error Response (401)
- **description**: API key missing or invalid.
- **content**: application/json schema referencing `OpenAIError`.
```
Tokens:
Raw