Getting Started Error Reference FAQ

Celiums — Documentation

84,000+ expert knowledge modules. One MCP connection. Every IDE.

Quick Start

Get Celiums running in your IDE in under 2 minutes.

Step 1: Get Your API Key

Run in your terminal:

npx @celiums/mcp --email [email protected]

You'll get a verification code by email:

⚡ Welcome to Celiums MCP

  Sending verification code...
  Code sent to [email protected]
  Enter 6-digit code: 482917
  ✓ Verified! API key saved.

Your key is saved automatically to ~/.celiums/credentials.json. You can also skip the code and start with temporary access — verify later with npx @celiums/mcp verify.

Didn't get the code? Check spam/promotions. Corporate email may block it — try a personal email. The code expires in 10 minutes.

Step 2: Configure Your IDE

Add Celiums to your IDE's MCP config. If you set the CELIUMS_API_KEY environment variable, you don't need to put the key in the config file.

Claude Code

Add to ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "celiums": {
      "command": "npx",
      "args": ["@celiums/mcp"],
      "env": {
        "CELIUMS_API_KEY": "sk-celiums_YOUR_KEY_HERE"
      }
    }
  }
}

Restart Claude Code after saving.

Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "celiums": {
      "command": "npx",
      "args": ["@celiums/mcp"],
      "env": {
        "CELIUMS_API_KEY": "sk-celiums_YOUR_KEY_HERE"
      }
    }
  }
}

Restart Cursor after saving.

VS Code + Continue

Add to ~/.continue/config.json inside the experimental block:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": ["@celiums/mcp"],
          "env": {
            "CELIUMS_API_KEY": "sk-celiums_YOUR_KEY_HERE"
          }
        }
      }
    ]
  }
}

Reload VS Code after saving.

VS Code Extension (sidebar UI)

We also offer a VS Code extension with sign-in, context cloud, and team presence — a sidebar companion to the MCP tools.

Install from file:

  1. Download celiums-0.2.0.vsix
  2. In VS Code: Ctrl+Shift+P → "Install from VSIX..." → select the file

Or from terminal:

curl -LO https://celiums.io/celiums-0.2.0.vsix
code --install-extension celiums-0.2.0.vsix

The extension adds a Celiums icon in the Activity Bar with sign-in, context save/load, and team chat. It works alongside the MCP config above.

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "celiums": {
      "command": "npx",
      "args": ["@celiums/mcp"],
      "env": {
        "CELIUMS_API_KEY": "sk-celiums_YOUR_KEY_HERE"
      }
    }
  }
}

Restart Windsurf after saving.

Tip: Instead of putting the key in the JSON file, set CELIUMS_API_KEY in your shell profile (~/.zshrc, ~/.bashrc) and use "CELIUMS_API_KEY": "" in the config. The MCP client reads from ~/.celiums/credentials.json and environment variables automatically.

Direct API Access (no IDE needed)

You can call the Celiums API directly over HTTPS using JSON-RPC 2.0. This works from any language, script, or curl:

curl -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-celiums_YOUR_KEY_HERE" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "forage",
      "arguments": {"query": "kubernetes deployment patterns"}
    },
    "id": 1
  }'

All available tools

Tool Arguments What it does
forage {"query": "search terms"} Search 84K+ modules by keyword
absorb {"name": "module-name"} Load a full module (e.g., react-mastery)
synthesize {"module": "name", "task": "your task"} AI applies the module methodology to your specific task
sense {"goal": "what you want to build"} Get intelligent module recommendations
bloom {"type": "blog_post", "topic": "..."} Generate complete documents
map_network {"domain": "category"} Browse all modules by category
account_status {} Check your plan, usage, and limits (free, never counted)
account_upgrade {"plan": "pro"} Get a direct Stripe payment link to upgrade
account_buy_credits {"pack": "starter"} Buy credit packs: starter (500/$5), power (2000/$15), bulk (10000/$50)
account_usage {"days": 7} View your request history

Examples

Search for modules:

curl -s -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CELIUMS_API_KEY" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"forage","arguments":{"query":"security audit"}},"id":1}'

Load a module:

curl -s -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CELIUMS_API_KEY" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"absorb","arguments":{"name":"react-mastery"}},"id":1}'

Check your account:

curl -s -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CELIUMS_API_KEY" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"account_status","arguments":{}},"id":1}'

Upgrade your plan:

curl -s -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CELIUMS_API_KEY" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"account_upgrade","arguments":{"plan":"pro"}},"id":1}'

List all tools (no auth needed):

curl -s -X POST https://api.celiums.io/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list","params":{},"id":1}'

Step 3: Test It Works

In your IDE's AI chat, type:

Use celiums to find best practices for React error boundaries

If you see the AI calling forage and returning module results, you're live.

How It Works

What is MCP?

MCP (Model Context Protocol) is an open standard that lets AI assistants call external tools during a conversation. When you ask your AI a question, it can call Celiums to fetch expert knowledge and use it in its answer — no copy-pasting, no tab switching.

What Are Modules?

A module is a structured knowledge unit focused on a single topic. Examples:

Module What it contains
react-mastery Hooks, patterns, performance, testing
postgresql-optimization Index strategies, EXPLAIN ANALYZE, N+1
security-audit OWASP top 10, code review, penetration testing
terraform-mastery HCL patterns, state management, multi-cloud
typescript-mastery Type system, advanced patterns, compiler options
docker-git-devops Containers, CI/CD, production deployments

All modules are AI-generated and continuously updated. They are not human-curated professional advice — see our Terms of Service for important disclaimers.

How Requests Are Counted

Each call to a Celiums tool counts as one request. Daily limits reset at 00:00 UTC.

Action Requests
forage (search) 1
absorb (load module) 1
synthesize (apply to task) 1
sense (recommendations) 1
bloom (generate docs) 1
account_status 0 (always free)
account_upgrade 0 (always free)
account_buy_credits 0 (always free)
account_usage 0 (always free)
absorb("celiums-docs") 0 (always free)

Account management tools and the celiums-docs module never count against your daily limit. A typical coding session uses 4-10 requests.

Architecture

Your IDE (Claude Code / Cursor / VS Code / Windsurf)
        │
        │  stdio (JSON-RPC 2.0)
        ▼
┌───────────────────┐
│  @celiums/mcp     │  ← local npm process started by your IDE
│  (MCP client)     │
└────────┬──────────┘
         │  HTTPS → api.celiums.io/mcp
         ▼
┌─────────────────────────────────────┐
│        Celiums API (Cloudflare)     │
│  84,000+ modules · PostgreSQL · AI │
└─────────────────────────────────────┘

Your source code never leaves your machine. Only tool call parameters (search queries, module IDs, task descriptions) travel to the Celiums API over HTTPS.

Account Management

Everything is done from your IDE — no web dashboard.

Check Your Status

Ask your AI assistant:

Check my celiums account status

The account_status tool shows your plan, daily usage, and remaining requests.

Upgrade Your Plan

Upgrade my celiums plan to pro

The account_upgrade tool returns a direct Stripe payment link. Click it to complete payment — your plan activates within seconds.

Available plans: pro ($19/mo), plus ($49/mo), network ($99/mo), team ($299/mo), business ($799/mo). See Pricing for details.

Buy Credits

Buy celiums credits

The account_buy_credits tool returns a payment link for credit packs:

Pack Price
500 credits $5
2,000 credits $15
10,000 credits $50

Credits never expire. They're used after your daily limit runs out.

View Usage

Show my celiums usage

The account_usage tool shows your request history by day and tool.

Regenerate Your Key

If your key is compromised, regenerate it immediately. Your old key stops working instantly.

curl -X POST https://api.celiums.io/api/auth/regenerate-key \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json"

After regenerating, update the key in your IDE config files and restart.

Note: Key regeneration requires JWT authentication (login via /api/auth/login). If you've lost both your API key and login credentials, email [email protected] with your registered email address.

Troubleshooting

"No API key found"

Error: No API key found.
Run this first to create your free account:
  npx @celiums/mcp --email [email protected]
Or provide a key: npx @celiums/mcp --api-key KEY

This means: The MCP server started but has no key. Either:

  1. Run npx @celiums/mcp --email [email protected] to create an account
  2. Set CELIUMS_API_KEY in your IDE config
  3. Check that ~/.celiums/credentials.json exists and has your key

"Auth required" (401)

{"error": {"code": -32001, "message": "Auth required. Get key at https://celiums.io"}}

Your key is missing, invalid, or revoked. Fixes:

  1. Check for typos — keys start with sk-celiums_
  2. Check for extra whitespace in the config
  3. The env var must be exactly CELIUMS_API_KEY
  4. If you regenerated the key, update all IDE configs

"Rate limit exceeded" (429)

You hit your daily limit. Options:

  • Buy credits — ask your AI: "Buy celiums credits"
  • Upgrade — ask: "Upgrade my celiums plan to pro"
  • Wait — limits reset at 00:00 UTC

Tools not appearing in IDE

  1. Verify the config file is valid JSON:
    python3 -m json.tool < ~/.cursor/mcp.json
  2. Verify Node.js ≥ 18:
    node --version
  3. Fully restart your IDE (quit and reopen, not just reload window)
  4. Check if npx can find the package:
    npx @celiums/mcp --help

Module not found

Use forage to search. Module names are lowercase with hyphens (e.g., react-mastery, not React Mastery or react/mastery).

Connection timeout

  1. Check your internet
  2. Test: curl -I https://api.celiums.io/health
  3. If behind a corporate proxy, set HTTPS_PROXY in your environment

Key recovery

  1. Check ~/.celiums/credentials.json — your key may be there
  2. Search IDE configs: grep -r "sk-celiums_" ~/.claude ~/.cursor ~/.continue ~/.codeium 2>/dev/null
  3. Re-authenticate: npx @celiums/mcp --email [email protected] — this issues a new key (old key is NOT revoked unless you explicitly regenerate)
  4. Contact: [email protected]

FAQ

What is Celiums? An MCP server with 84,000+ expert AI modules for coding assistants. One API key gives your AI access to structured knowledge across 98 categories.

What is MCP? Model Context Protocol — an open standard that lets AI assistants call external tools. You don't need to understand MCP to use Celiums.

Which IDEs work? Claude Code, Cursor, VS Code (via Continue), Windsurf, and any MCP-compatible client.

Is my code sent to Celiums? No. Only search queries, module IDs, and task descriptions are sent. Your source code stays local.

Are modules reviewed by humans? No. All modules are AI-generated. They are for informational purposes only and should not be treated as professional advice. See our Terms of Service.

What counts as a request? Each tool call (forage, absorb, synthesize, etc.) = 1 request. Account tools are always free.

When do limits reset? Daily at 00:00 UTC.

Can I use one key on multiple machines? Yes. All machines share the same daily limit.

Can I cancel anytime? Yes. Downgrade to free from your IDE or via Stripe billing portal.

Do unused requests roll over? No. Buy credit packs if you need rollover capacity — credits never expire.

What if I lose my key? Check ~/.celiums/credentials.json. If not there, run npx @celiums/mcp --email [email protected] to get a new one.

Is there a web dashboard? No. Everything is managed from your IDE via MCP tools. This is intentional — we believe developers should stay in their editor.

Do you have a status page? Check curl https://api.celiums.io/health for real-time API status.

How do I contact support? Email [email protected] or [email protected].

Celiums.io MCP API Error Reference

This document provides a comprehensive guide to all errors returned by the Celiums.io Model Context Protocol (MCP) API. Celiums uses standard JSON-RPC 2.0 error codes wrapped in HTTP responses.

Error Response Format

All API errors follow this JSON structure:

{
  "jsonrpc": "2.0",
  "id": "request_id",
  "error": {
    "code": -32000,
    "message": "Error message description",
    "data": {
      "details": "Specific diagnostic information",
      "docs": "https://docs.celiums.io/errors/code"
    }
  }
}

1. Authentication Errors

Invalid API Key

  • Message: Invalid API key provided.
  • JSON-RPC Code: -32001
  • HTTP Status: 401 Unauthorized
  • Cause: The CELIUMS_API_KEY provided does not match any record in our database or is mistyped.
  • Fix:
    1. Log in to the Celiums Dashboard.
    2. Copy your API key again.
    3. Update your MCP configuration file (e.g., claude_desktop_config.json).
    4. Restart your IDE/MCP client.
  • Prevention: Use environment variables instead of hardcoding keys to avoid truncation or copy-paste errors.

Missing Authorization Header

  • Message: Authorization header is missing.
  • JSON-RPC Code: -32001
  • HTTP Status: 401 Unauthorized
  • Cause: The request was sent without the Authorization: Bearer <key> header.
  • Fix: Ensure your MCP client is passing the env variables correctly to the Celiums executable.
  • Prevention: Verify your claude_desktop_config.json includes the env block for the Celiums server.

Expired Key

  • Message: API key has expired.
  • JSON-RPC Code: -32002
  • HTTP Status: 401 Unauthorized
  • Cause: Temporary keys or keys associated with a trial that has ended have lapsed.
  • Fix: Generate a new key from the Celiums Dashboard.
  • Prevention: Monitor key expiration dates in the security settings of your account.

Revoked Key

  • Message: API key has been revoked.
  • JSON-RPC Code: -32002
  • HTTP Status: 403 Forbidden
  • Cause: The key was manually deleted in the dashboard or flagged for security violations (e.g., leaked on GitHub).
  • Fix: Create a new API key and update your local configuration.
  • Prevention: Never commit your API keys to version control.

Wrong Key Format

  • Message: Invalid API key format.
  • JSON-RPC Code: -32001
  • HTTP Status: 400 Bad Request
  • Cause: The key does not follow the clm_... prefix format.
  • Fix: Ensure you haven't included quotes or the word "Bearer" inside the environment variable value itself.

2. Rate Limiting

Daily Limit Exceeded

  • Message: Daily request limit reached for your current plan.
  • JSON-RPC Code: -32005
  • HTTP Status: 429 Too Many Requests
  • Cause: You have exhausted your daily quota.
    • Free: 50 requests/day
    • Pro: 2,000 requests/day
    • Plus: 10,000 requests/day
  • What happens: All subsequent requests will fail until 00:00 UTC.
  • How to check: Call the get_account_usage tool or check the Dashboard.
  • Fix:
    1. Use the account_upgrade tool directly in your IDE.
    2. Type: "Upgrade my Celiums account to Pro."
    3. Follow the link provided to complete the checkout.
  • Prevention: Optimize your prompts to reduce unnecessary tool calls.

3. Module Errors

Module Not Found

  • Message: The requested module '<module_name>' does not exist.
  • JSON-RPC Code: -32601
  • HTTP Status: 404 Not Found
  • Cause: You attempted to call a tool from a module that isn't installed or is misspelled.
  • Fix: Use the list_modules tool to see available modules.
  • Prevention: Always use the exact string returned by list_modules.

Module Access Denied

  • Message: Module '<module_name>' requires a Pro or Plus subscription.
  • JSON-RPC Code: -32003
  • HTTP Status: 403 Forbidden
  • Cause: Attempting to use a Premium module (e.g., Advanced Data Research) on a Free tier.
  • Fix: Upgrade your plan via the account_upgrade tool or the website.
  • Prevention: Check the module documentation for "Tier Requirements" before integration.

Module Content Too Large

  • Message: Module response exceeds maximum context window.
  • JSON-RPC Code: -32006
  • HTTP Status: 413 Payload Too Large
  • Cause: The data returned by the module is too large for the MCP transport layer (usually > 4MB).
  • Fix: Use filters or parameters to limit the search results or data requested.
  • Prevention: Use pagination parameters where available.

4. Connection Errors

Timeout

  • Message: Request to Celiums upstream timed out.
  • JSON-RPC Code: -32004
  • HTTP Status: 504 Gateway Timeout
  • Cause: The Celiums server took longer than 30 seconds to process the request.
  • Fix: Check your internet connection; retry the request after 10 seconds.
  • Prevention: If performing heavy data tasks, break them into smaller sub-tasks.

DNS Resolution Failure / SSL Errors

  • Message: Could not resolve host: api.celiums.io or SSL Certificate Verification Failed.
  • JSON-RPC Code: -32000
  • HTTP Status: N/A (Local Error)
  • Cause: Local network issues, firewall blocking, or outdated CA certificates.
  • Fix:
    1. Ping api.celiums.io.
    2. Ensure your system clock is synchronized.
    3. Update your Node.js/Python environment.
  • Prevention: Whitelist *.celiums.io in your corporate firewall.

5. Billing Errors

Payment Failed

  • Message: Subscription inactive. Please update payment method.
  • JSON-RPC Code: -32007
  • HTTP Status: 402 Payment Required
  • Cause: Recurring payment failed (insufficient funds, expired card).
  • Fix: Go to Dashboard > Billing and update your credit card.
  • Prevention: Enable "Auto-renew" and keep a secondary payment method on file.

Plan Downgrade Effects

  • Message: Feature unavailable on your current plan.
  • JSON-RPC Code: -32003
  • HTTP Status: 403 Forbidden
  • Cause: You recently downgraded from Pro to Free, and are trying to use Pro-only tools.
  • Fix: Re-subscribe to Pro or switch to Free-tier equivalent tools.

6. IDE-Specific Errors (Claude/Cursor)

MCP Server Not Starting

  • Error Message in IDE: MCP Server "Celiums" exited with code 1.
  • Cause: Usually a path error in the config file or missing environment variables.
  • Fix:
    1. Open claude_desktop_config.json.
    2. Verify the command path points to the correct npx or python executable.
    3. Ensure env contains CELIUMS_API_KEY.
  • Example Correct Config:
    "mcpServers": {
  "celiums": {
    "command": "npx",
    "args": ["-y", "@celiums/mcp-server"],
    "env": {
      "CELIUMS_API_KEY": "clm_your_key_here"
    }
  }
}

Tools Not Appearing

  • Cause: The IDE failed to parse the server's listTools response.
  • Fix: Restart the IDE completely. Check the logs in ~/Library/Logs/Claude/mcp.log (macOS) for specific parse errors.

Config Parse Error

  • Error Message: Failed to load MCP config: Unexpected token...
  • Cause: Syntax error (missing comma or quote) in your JSON config.
  • Fix: Run your config through a JSON validator (like JSONLint).

Celiums.io — Complete FAQ & Self-Service Guide

Celiums is an MCP server with 84,000+ expert AI modules you can use from your IDE and MCP-compatible clients. Authentication is API key based, with plans ranging from Free to $799/month.

This guide covers setup, API keys, billing, usage limits, teams, troubleshooting, and security.

Getting Started

1) What is Celiums?

Celiums is an MCP server that gives your IDE or MCP client access to 84K+ expert AI modules through a single API key.

You can use Celiums to:

  • Call specialized AI modules from your editor
  • Connect through MCP-compatible IDEs and tools
  • Manage access with your Celiums account and API key
  • Upgrade plans, check usage, and buy credits

In practical terms:

  1. You create an account
  2. You generate an API key
  3. You add the key to your MCP client or IDE
  4. You start using Celiums tools/modules

2) What is MCP?

MCP stands for Model Context Protocol.

It is a standard that lets AI clients, IDEs, and coding tools connect to external servers that provide:

  • tools
  • resources
  • prompts
  • remote capabilities

Celiums acts as an MCP server, which means your IDE can discover and call Celiums-provided tools and modules.

Think of it like this:

  • Your IDE/client = the app you use
  • MCP = the protocol/bridge
  • Celiums = the remote server providing modules and tools

3) Which IDEs are supported?

Celiums works with MCP-compatible clients and IDEs.

Common supported environments include:

  • Cursor
  • Claude Desktop
  • Windsurf
  • VS Code setups that support MCP
  • Other MCP clients that allow custom server configuration

If your IDE supports adding an MCP server with:

  • a command
  • environment variables
  • or server configuration JSON

…then Celiums will usually work.

How to verify compatibility

Check whether your client supports:

  • MCP servers
  • remote/server transport
  • env vars for API keys
  • tool discovery

If it does, Celiums should be compatible.

4) How do I sign up?

Follow these steps:

  1. Go to Celiums.io
  2. Create your account
  3. Verify your email if prompted
  4. Open your dashboard
  5. Generate your API key
  6. Add the key to your MCP client configuration

Typical setup flow

After signup:

  • open Dashboard
  • go to API Keys
  • click Create Key
  • copy the key immediately
  • store it in a password manager

Example environment variable:

export CELIUMS_API_KEY="sk-celiums_your_key_here"

On Windows PowerShell:

$env:CELIUMS_API_KEY="sk-celiums_your_key_here"

On Windows CMD:

set CELIUMS_API_KEY=sk-celiums_your_key_here

5) Is there a free plan?

Yes. Celiums offers a Free plan.

The Free plan is intended for:

  • testing setup
  • evaluating modules
  • light usage
  • initial IDE integration

If you need higher usage, better limits, or more features, you can upgrade to a paid plan.

Best way to start

  1. Create a free account
  2. Generate a key
  3. Connect your IDE
  4. Test a simple tool call
  5. Upgrade only if needed

6) How do I test if it works?

The fastest way is to confirm:

  • your key is set
  • your MCP client can see Celiums tools
  • a basic Celiums tool responds

Step 1: Set your API key

export CELIUMS_API_KEY="sk-celiums_your_key_here"

Step 2: Restart your IDE/client

Most MCP clients only load env vars at startup.

Step 3: Confirm Celiums tools appear

Look for tools such as:

  • account_status
  • account_upgrade

Step 4: Run a basic check

Use the account_status tool from your MCP client.

Expected result:

  • your plan
  • usage info
  • remaining limits
  • account state

If account_status works, your connection and authentication are working.

API Keys & Authentication

1) Where do I find my key?

You can find or create your key in the Celiums dashboard.

Steps

  1. Log in to Celiums.io
  2. Open Dashboard
  3. Go to API Keys
  4. View existing keys or click Create Key

If keys are only shown once, copy it immediately and store it securely.

Recommended storage:

  • 1Password
  • Bitwarden
  • Dashlane
  • your company secrets manager

2) I lost my key, what do I do?

If you no longer have the full key value:

  1. Go to Dashboard → API Keys
  2. Revoke the missing key
  3. Create a new key
  4. Update all clients, IDEs, CI jobs, and scripts

Do not wait

If you cannot recover the original key, treat it as unusable and rotate immediately.

Update your environment

macOS/Linux:

export CELIUMS_API_KEY="sk-celiums_new_key_here"

PowerShell:

$env:CELIUMS_API_KEY="sk-celiums_new_key_here"

3) Can I have multiple keys?

Yes, if your account/dashboard supports multiple active keys, you can create them for different uses such as:

  • local development
  • work laptop
  • CI/CD
  • shared team automations
  • staging vs production

Best practice:

  • use one key per environment
  • label them clearly
  • revoke unused keys regularly

Example labels:

  • macbook-dev
  • cursor-workstation
  • github-actions
  • team-backend-prod

4) Can I use one key on multiple machines?

Yes, technically you can use the same key on multiple machines, but it is not recommended.

Best practice:

  • use separate keys per machine or environment

Why:

  • easier auditing
  • safer revocation
  • simpler debugging
  • lower blast radius if a key leaks

Recommended:

  • one key for desktop
  • one key for laptop
  • one key for CI

5) Someone saw my key, what now?

Treat the key as compromised.

Immediate action

  1. Go to Dashboard → API Keys
  2. Revoke the exposed key immediately
  3. Create a replacement key
  4. Update all systems using the old key
  5. Check usage and billing activity

If you exposed it publicly

If it appeared in:

  • GitHub
  • GitLab
  • screenshots
  • logs
  • Discord/Slack
  • support tickets

…rotate it immediately.

Also do this

  • remove the key from source control
  • invalidate shell history if needed
  • scan repos for leaked keys

Example search:

grep -R "sk-celiums_" .

If committed to git:

git log -p | grep "sk-celiums_"

Then rewrite history if necessary.

6) How do I rotate my key?

Key rotation means replacing an old key with a new one safely.

Safe rotation process

  1. Create a new key
  2. Update your apps and clients to use the new key
  3. Test with account_status
  4. Revoke the old key

Example

Set new key:

export CELIUMS_API_KEY="sk-celiums_new_key_here"

Test in client using:

  • account_status

Once confirmed:

  • revoke old key in dashboard

Rotation schedule

Recommended:

  • every 60–90 days
  • immediately after employee offboarding
  • immediately after suspected exposure

7) Key format — what does sk-celiums_ mean?

sk-celiums_ is the prefix used for Celiums secret API keys.

Typical structure:

sk-celiums_xxxxxxxxxxxxxxxxx

What it means:

  • sk = secret key
  • celiums = Celiums-issued credential
  • remainder = unique secret token

Important

  • The prefix is public and normal
  • The rest of the key is secret
  • Never share the full key

If your key does not begin with sk-celiums_, double-check that you copied it correctly.

Billing & Plans

1) What counts as a request?

A request is typically counted when your MCP client successfully calls a Celiums module or tool.

This usually includes:

  • tool invocations
  • module executions
  • account/tool checks such as supported service calls
  • API-backed module runs

It may not include:

  • opening your IDE
  • viewing local config
  • typing prompts before execution

Rule of thumb

If your client sends a real Celiums tool/module call to the server, it likely counts as a request.

To verify actual usage:

  • run account_status

2) When do limits reset?

Celiums usage limits reset at UTC midnight.

That means:

  • daily usage resets at 00:00 UTC
  • monthly limits reset according to your billing cycle, if applicable
  • request buckets tied to daily limits refresh at UTC day boundaries

Check current UTC time

macOS/Linux:

date -u

PowerShell:

Get-Date -AsUTC

If you are waiting for reset after hitting a daily limit, use UTC rather than your local timezone.

3) How do I upgrade? (account_upgrade tool)

You can upgrade using the account_upgrade tool from your MCP client, if available in your environment.

Steps

  1. Open your MCP client/IDE
  2. Make sure Celiums is connected
  3. Run the account_upgrade tool
  4. Select the desired plan
  5. Confirm payment/update details if prompted

Verify after upgrade

Run:

  • account_status

You should see:

  • updated plan
  • new limits
  • active billing status

If your client does not expose account_upgrade, upgrade from the Celiums dashboard billing page.

4) How do I buy credits?

If Celiums offers prepaid or add-on credits on your plan:

  1. Log in to Celiums.io
  2. Go to Billing or Credits
  3. Choose the credit amount/package
  4. Complete payment
  5. Confirm balance in dashboard or with account_status

If credits are tool-enabled in your client:

  • use the relevant billing/credits workflow if shown

Best practice

Buy credits when:

  • you are near your monthly cap
  • you need temporary burst capacity
  • you want to avoid interruption before plan renewal

5) Can I get a refund?

Refund eligibility depends on:

  • plan type
  • billing timing
  • actual usage
  • local consumer law
  • contract terms for enterprise accounts

Best next step

Contact billing/support with:

  • account email
  • invoice ID
  • charge date
  • reason for refund

Include:

  • whether the account was used
  • whether the charge was accidental
  • whether the plan auto-renewed unexpectedly

If you want to avoid future charges:

  • cancel or downgrade before renewal
  • remove or update expired payment methods

6) What happens if my card expires?

If your card expires or fails:

  • renewal may fail
  • your paid plan may lapse
  • usage may pause, downgrade, or move to free-tier behavior depending on account status

Fix it

  1. Log in to Celiums.io
  2. Go to Billing
  3. Update your payment method
  4. Retry payment if prompted
  5. Confirm plan state with account_status

If service stopped

After updating billing:

  • re-run account_status
  • retry your module/tool call
  • contact support if your plan does not restore

7) Pro vs Plus — what is the difference?

The exact differences depend on the current pricing page, but usually higher tiers include one or more of:

  • more monthly requests
  • higher rate limits
  • access to more premium modules
  • better concurrency
  • priority support
  • team/admin features

How to compare

Check:

  • request limits
  • burst/rate limits
  • premium module access
  • team features
  • support level
  • billing flexibility

Best way to verify your current plan

Run:

  • account_status

And compare with the current plans page on Celiums.io.

8) Do you offer annual plans?

Annual plans may be available depending on current Celiums pricing and contract options.

How to check

  1. Open the pricing page
  2. Check Billing settings
  3. Look for annual toggle or enterprise sales option

If not visible publicly:

  • contact sales/support
  • ask about annual invoicing
  • ask about enterprise contracts
  • ask about volume discounts

Annual plans are most common for:

  • teams
  • enterprise customers
  • procurement-based organizations

Usage & Limits

1) I hit my rate limit, what now?

If you see rate limit exceeded:

  1. stop retrying rapidly
  2. wait for the limit window to reset
  3. reduce request frequency
  4. check usage with account_status
  5. upgrade plan or buy credits if needed

Immediate actions

  • close duplicate IDE sessions
  • reduce parallel tool calls
  • disable runaway automations
  • retry after a short delay

Good retry approach

Use exponential backoff:

  • wait 5 seconds
  • then 10
  • then 20
  • then 40

If it happens often

  • upgrade your plan
  • split workloads over time
  • reduce repeated module calls

2) How do I check my usage? (account_status tool)

Use the account_status tool.

It is the fastest way to view:

  • current plan
  • request usage
  • limit remaining
  • billing/account state
  • possible reset information

Steps

  1. Open your MCP client
  2. Run account_status
  3. Review usage and account details

If the tool is missing:

  • confirm Celiums is connected
  • restart the IDE
  • verify your API key
  • check MCP config

3) What modules are free?

Free availability depends on the current Celiums catalog and plan rules.

In general:

  • some modules are available on the Free plan
  • premium or high-cost modules may require paid plans or credits
  • certain modules may have separate usage weighting or restrictions

How to check

  • browse the module catalog in your client/dashboard
  • look for Free/Pro/Premium labels
  • run account_status for plan context
  • consult the pricing page for feature access

If a module fails due to plan restrictions:

  • upgrade plan
  • buy credits if applicable
  • choose a module included in your current tier

4) Can I use Celiums offline?

No. Celiums is a remote MCP server, so an internet connection is required.

You cannot fully use Celiums offline because:

  • tool calls go to the Celiums server
  • authentication must be validated
  • modules execute remotely

What you can do offline

  • edit your MCP config
  • prepare prompts locally
  • write code in your IDE
  • reconnect later and resume using Celiums

If you need reliable access:

  • use a stable network
  • avoid restrictive corporate proxies without allowlisting
  • test DNS/firewall rules

5) How fast are responses?

Response speed depends on:

  • module complexity
  • current server load
  • your network latency
  • IDE/client overhead
  • request size/context size

Typical experience:

  • account/tool checks are usually fast
  • lightweight modules respond quickly
  • large or complex module runs take longer

If responses feel slow

  • test with account_status
  • try a simpler module
  • check your internet connection
  • restart the IDE
  • reduce concurrent requests

If simple calls are slow too, the issue is likely:

  • network
  • local IDE state
  • temporary service load

Teams & Enterprise

1) How do I add team members?

If your plan includes team management:

  1. Log in to Celiums.io
  2. Open Team, Members, or Organization Settings
  3. Click Invite Member
  4. Enter their email
  5. Assign role if prompted
  6. Send invite

Typical roles may include:

  • Owner
  • Admin
  • Member
  • Billing

Best practice

  • do not share one API key across a team
  • invite members individually
  • issue separate credentials/keys where supported

2) What is SSO?

SSO means Single Sign-On.

It lets your organization’s identity provider handle login, usually through:

  • SAML
  • OIDC
  • Google Workspace
  • Okta
  • Azure AD / Microsoft Entra

Benefits:

  • centralized access control
  • easier onboarding/offboarding
  • stronger security policies
  • MFA enforcement through your IdP

If you need SSO:

  • check enterprise plan options
  • contact sales/support for setup

3) Do you support HIPAA?

HIPAA support usually requires a specific agreement and technical scope, not just a feature checkbox.

If you need HIPAA:

  1. Contact Celiums sales/support before sending any PHI
  2. Ask whether HIPAA-supported plans/environments are available
  3. Ask whether a BAA is offered
  4. Do not process regulated data until written confirmation is in place

Important

Do not assume HIPAA coverage by default.

4) Can I get an SLA?

SLA availability is usually tied to:

  • enterprise plans
  • custom contracts
  • higher support tiers

Typical SLA items include:

  • uptime commitment
  • support response times
  • incident communication
  • service credits

How to request one

Contact sales/support with:

  • company name
  • expected volume
  • uptime needs
  • support requirements
  • security/compliance requirements

5) Data residency options?

Data residency availability depends on Celiums infrastructure and enterprise offerings.

If your company requires a specific region:

  • ask sales/support what regions are available
  • ask where data is stored and processed
  • ask whether region pinning is supported
  • ask whether backups/logs stay in-region

This matters for:

  • GDPR
  • internal policy
  • regulated workloads
  • procurement reviews

Troubleshooting

1) MCP tools not showing up

If Celiums tools are missing from your IDE:

Checklist

  1. Confirm your API key is set
  2. Confirm your MCP config points to Celiums
  3. Restart the IDE/client
  4. Check for JSON/config syntax errors
  5. Confirm the client supports MCP tool discovery

Verify env var

macOS/Linux:

echo $CELIUMS_API_KEY

PowerShell:

echo $env:CELIUMS_API_KEY

Common issue

You set the env var after launching the IDE.
Fix: close the IDE completely and reopen it.

Also check

  • duplicated config entries
  • invalid server command
  • blocked network access
  • outdated client version

2) Connection timeout

A timeout usually means your client cannot reach Celiums reliably.

Check these first

  • internet connection
  • firewall/proxy restrictions
  • DNS resolution
  • VPN interference
  • corporate endpoint filtering

Quick tests

macOS/Linux:

ping celiums.io

nslookup celiums.io

PowerShell:

Test-NetConnection celiums.io

If behind a corporate proxy

Ask IT to allow outbound access to:

  • Celiums domains
  • MCP transport endpoints
  • required TLS/HTTPS traffic

Also try

  • disable VPN temporarily
  • restart IDE
  • retry from another network

3) Module not found

If you get module not found:

Possible causes

  • typo in module name
  • module removed or renamed
  • plan does not include that module
  • stale IDE tool/module cache
  • wrong environment/client config

Fix

  1. Search the module catalog again
  2. Confirm exact spelling
  3. Refresh/restart your client
  4. Check your plan with account_status
  5. Try another known module

If a previously working module disappeared:

  • restart the IDE
  • re-sync available tools/modules
  • check release notes or dashboard notices

4) Error: Auth required

This means Celiums did not receive a valid API key.

Fix

  1. Check that CELIUMS_API_KEY is set
  2. Confirm it starts with sk-celiums_
  3. Make sure there are no extra spaces or quotes
  4. Restart the IDE
  5. Revoke/regenerate the key if needed

Check value

macOS/Linux:

printf '%s\n' "$CELIUMS_API_KEY"

PowerShell:

$env:CELIUMS_API_KEY

Common mistakes

  • wrong env var name
  • expired/revoked key
  • copied partial key
  • using an old key in IDE settings while shell has a new one

5) Error: Rate limit exceeded

This means your account or key has exceeded its allowed request rate or quota window.

Fix now

  • wait and retry later
  • reduce concurrency
  • stop repeated retries
  • check usage with account_status

If urgent

  • upgrade using account_upgrade
  • buy credits if available
  • move non-urgent tasks until after reset

Prevent it

  • spread calls across time
  • avoid loops/automation storms
  • use one request where five would do

6) IDE froze after using Celiums

This is often caused by:

  • too many concurrent requests
  • heavy prompt/context payloads
  • extension/client bugs
  • local memory pressure
  • a hung MCP subprocess/client transport

Fix

  1. Save your work
  2. Fully quit the IDE
  3. Reopen it
  4. Retry with a simple call like account_status
  5. Reduce context size
  6. Update the IDE and MCP-related extensions

If it keeps happening

  • test in another MCP client
  • disable other heavy extensions
  • check Activity Monitor / Task Manager
  • use a separate key to isolate environment issues

On macOS/Linux, inspect memory/processes:

ps aux | grep -i -E "cursor|code|claude|windsurf"

On Windows:

  • open Task Manager
  • inspect CPU/memory usage
  • end stuck processes if necessary

Security & Privacy

1) What data do you collect?

Celiums typically needs to collect some operational data to provide the service, such as:

  • account information
  • billing information
  • API usage metadata
  • request logs or diagnostics
  • tool/module usage records
  • security and abuse-prevention signals

Exact collection depends on:

  • your plan
  • enabled features
  • support/debugging activity
  • legal/compliance requirements

To verify current policy

Review:

  • Privacy Policy
  • Terms of Service
  • Data Processing Addendum, if offered

2) Where is data stored?

Data storage location depends on Celiums infrastructure and plan.

This may include:

  • primary application databases
  • logs/monitoring systems
  • backups
  • billing systems
  • support systems

If storage region matters to you:

  1. check the privacy/security documentation
  2. ask support for current hosting regions
  3. ask sales about enterprise region options

3) Can I delete my account?

In most cases, yes.

Typical process

  1. Log in to Celiums.io
  2. Go to Account Settings
  3. Look for Delete Account or Close Account
  4. Follow confirmation steps

If self-serve deletion is not visible:

  • contact support
  • request account deletion
  • include your account email
  • revoke all API keys first if possible

Before deleting

  • export invoices/receipts
  • remove team members
  • cancel paid subscription
  • revoke keys
  • remove Celiums from local configs

4) Is my code sent to Celiums?

If you use Celiums modules from your IDE, the content needed for the request may be sent to Celiums so the module can operate.

That can include:

  • prompts
  • code snippets
  • files or context your IDE/client sends
  • tool arguments

Important

Celiums only sees what your client transmits.

Best practice

  • review what your IDE shares with MCP tools
  • avoid sending secrets unnecessarily
  • redact tokens, passwords, and credentials
  • do not send regulated data unless your compliance requirements are covered

5) SOC 2 / GDPR compliance?

Compliance status can change over time, so the authoritative source is Celiums documentation or sales/security responses.

For SOC 2

Ask:

  • do you have SOC 2 Type I or Type II?
  • can you share a report under NDA?
  • what systems are in scope?

For GDPR

Ask:

  • do you offer a DPA?
  • where is data processed?
  • what subprocessors are used?
  • how are deletion/access requests handled?

Best practice for buyers

Request:

  • security documentation
  • DPA
  • subprocessor list
  • retention details
  • incident response information

Quick Self-Service Commands

Check API key is set

macOS/Linux:

echo $CELIUMS_API_KEY

PowerShell:

echo $env:CELIUMS_API_KEY

Set API key

macOS/Linux:

export CELIUMS_API_KEY="sk-celiums_your_key_here"

PowerShell:

$env:CELIUMS_API_KEY="sk-celiums_your_key_here"

CMD:

set CELIUMS_API_KEY=sk-celiums_your_key_here

Check UTC time for reset window

macOS/Linux:

date -u

PowerShell:

Get-Date -AsUTC

Search local files for leaked key

grep -R "sk-celiums_" .

Basic DNS/network test

nslookup celiums.io

ping celiums.io

Recommended Setup Checklist

  • Create Celiums account
  • Generate API key
  • Store key in password manager
  • Set CELIUMS_API_KEY
  • Configure your MCP client
  • Restart IDE/client
  • Confirm tools appear
  • Run account_status
  • Test one module
  • Rotate old/shared keys if needed

Recommended Security Checklist

  • Never commit keys to git
  • Use one key per machine/environment
  • Rotate keys every 60–90 days
  • Revoke exposed keys immediately
  • Avoid sending secrets in prompts
  • Review team member access regularly
  • Update payment method before renewal
  • Check usage with account_status

If you want, I can also turn this into:

  1. a docs-site version with headings and anchors, or
  2. a customer support help center version with shorter answers and CTA links.