---
name: internet-court/chaingpt
source: https://app.decimal.ai/s/internet-court-chaingpt@1/SKILL.md
source_sha256: 7ce5575b1a3d
---

# ChainGPT Developer Skill

You are an expert at building with the ChainGPT Web3 AI platform. When a developer asks you to integrate any ChainGPT product, you know the exact endpoints, SDK methods, parameters, pricing, and best practices.

## Platform Overview

ChainGPT provides AI infrastructure for Web3 via APIs, SDKs, and whitelabel SaaS. All API products share:

- **Base URL:** `https://api.chaingpt.org`
- **Auth:** `Authorization: Bearer <API_KEY>` header
- **Rate Limit:** 200 requests/minute per key
- **Credits:** 1 CGPTc = $0.01 USD (never expire). Purchase at https://app.chaingpt.org/addcredits
- **API Dashboard:** https://app.chaingpt.org/apidashboard
- **SDKs:** JavaScript/TypeScript (Node.js) + Python for all products

### Getting an API Key

1. Visit https://app.chaingpt.org — connect a crypto wallet to sign up
2. Navigate to API Keys → "Create New Secret Key"
3. Store the key securely (env var or secret manager — shown only once)
4. Ensure sufficient credits (crypto, $CGPT token, or credit card)
5. 15% bonus when paying with $CGPT or via monthly auto-top-up

## Products at a Glance

| Product | NPM Package | Model ID / Endpoint | Cost per Request |
|---------|-------------|-------------------|-----------------|
| Web3 AI Chatbot & LLM | `@chaingpt/generalchat` | `general_assistant` via `POST /chat/stream` | 0.5 credits (+0.5 w/ history) |
| AI NFT Generator | `@chaingpt/nft` | `POST /nft/generate-image` + 5 more | 1-14.25 credits (model/upscale) |
| Smart Contract Generator | `@chaingpt/smartcontractgenerator` | `smart_contract_generator` via `POST /chat/stream` | 1 credit (+1 w/ history) |
| Smart Contract Auditor | `@chaingpt/smartcontractauditor` | `smart_contract_auditor` via `POST /chat/stream` | 1 credit (+1 w/ history) |
| AI Crypto News | `@chaingpt/ainews` | `GET /news` | 1 credit per 10 records |
| AgenticOS | Open-source (GitHub) | Self-hosted | 1 credit per generated tweet |
| Solidity LLM | Open-source (HuggingFace) | Local inference | Free (self-hosted) |

Python: `pip install chaingpt` (unified package for all products)

## Quick Starts

### 1. Web3 AI Chatbot & LLM

The LLM is fine-tuned for crypto/blockchain with live on-chain data, Nansen Smart Money, token analytics, and 33+ chain support.

**JavaScript:**
```javascript
import { GeneralChat } from '@chaingpt/generalchat';
const chat = new GeneralChat({ apiKey: process.env.CHAINGPT_API_KEY });

// Buffered response
const res = await chat.createChatBlob({
  question: 'What is the current ETH price and market sentiment?',
  chatHistory: 'off'
});
console.log(res.data.bot);

// Streaming response
const stream = await chat.createChatStream({
  question: 'Analyze the top DeFi protocols by TVL',
  chatHistory: 'on',
  sdkUniqueId: 'session-123'
});
stream.on('data', chunk => process.stdout.write(chunk.toString()));
```

**Python:**
```python
from chaingpt.client import ChainGPTClient
from chaingpt.models import LLMChatRequestModel
from chaingpt.types import ChatHistoryMode

async with ChainGPTClient(api_key=API_KEY) as client:
    res = await client.llm.chat(LLMChatRequestModel(
        question="Explain yield farming strategies",
        chatHistory=ChatHistoryMode.OFF
    ))
    print(res.data.bot)
```

**REST (single endpoint for all chat-based products):**
```bash
curl -X POST "https://api.chaingpt.org/chat/stream" \
  -H "Authorization: Bearer $CHAINGPT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"general_assistant","question":"How do Ethereum smart contracts work?","chatHistory":"off"}'
```

> For full parameter reference (context injection, custom tones, blockchain enums, chat history retrieval), read `reference/llm-chatbot.md`.

### 2. AI NFT Generator

Generate images from text prompts, mint as NFTs across 22+ chains. Four models: VeloGen (fast), NebulaForge XL (detailed), VisionaryForge (general), Dale3 (DALL-E 3).

**JavaScript:**
```javascript
import { Nft } from '@chaingpt/nft';
const nft = new Nft({ apiKey: process.env.CHAINGPT_API_KEY });

// Generate image
const img = await nft.generateImage({
  prompt: 'A cyberpunk dragon guarding a blockchain vault',
  model: 'nebula_forge_xl', height: 1024, width: 1024, steps: 25, enhance: '1x'
});

// Generate + mint NFT
const gen = await nft.generateNft({
  prompt: 'Cosmic whale swimming through DeFi protocols',
  model: 'velogen', height: 512, width: 512, steps: 3,
  walletAddress: '0xYOUR_WALLET', chainId: 56, amount: 1
});
const mint = await nft.mintNft({
  collectionId: gen.data.collectionId,
  name: 'Cosmic Whale #1', description: 'AI-generated NFT', symbol: 'WHALE', ids: [1]
});
```

> For all endpoints (generate-image, generate-multiple-images, queue, progress, mint, enhancePrompt, get-chains, abi), models, styles, chain IDs, and pricing, read `reference/nft-generator.md`.

### 3. Smart Contract Generator

Natural language to production Solidity. Powered by ChainGPT's Solidity LLM.

**JavaScript:**
```javascript
import { SmartContractGenerator } from '@chaingpt/smartcontractgenerator';
const gen = new SmartContractGenerator({ apiKey: process.env.CHAINGPT_API_KEY });

const res = await gen.createSmartContractBlob({
  question: 'Create an ERC-20 token called "MyToken" with symbol "MTK", 1 billion supply, 2% burn on transfer, and owner-only minting',
  chatHistory: 'off'
});
console.log(res.data.bot); // Full Solidity contract
```

> Full reference: `reference/smart-contract-generator.md`

### 4. Smart Contract Auditor

AI-powered vulnerability detection, scoring (0-100%), and remediation recommendations.

**JavaScript:**
```javascript
import { SmartContractAuditor } from '@chaingpt/smartcontractauditor';
const auditor = new SmartContractAuditor({ apiKey: process.env.CHAINGPT_API_KEY });

const res = await auditor.auditSmartContractBlob({
  question: `Audit this contract:\n\n${contractSourceCode}`,
  chatHistory: 'off'
});
console.log(res.data.bot); // Detailed audit report
```

> Full reference: `reference/smart-contract-auditor.md`

### 5. AI Crypto News

Real-time AI-curated news via Nova AI engine. 24 categories, 50+ blockchain filters, 30 token filters. Also available as free RSS feeds.

**JavaScript:**
```javascript
import { AINews } from '@chaingpt/ainews';
const news = new AINews({ apiKey: process.env.CHAINGPT_API_KEY });

const res = await news.getNews({
  categoryId: [5],        // DeFi
  subCategoryId: [15],    // Ethereum
  limit: 10, offset: 0, sortBy: 'createdAt'
});
res.data.forEach(a => console.log(`${a.title} — ${a.url}`));
```

**Free RSS (no auth):** `https://app.chaingpt.org/rssfeeds.xml` (all), `-bitcoin.xml`, `-bnb.xml`, `-ethereum.xml`

> Full reference with all category/subcategory/token IDs: `reference/crypto-news.md`

### 6. AgenticOS (Open-Source Twitter AI Agent)

TypeScript/Bun framework for autonomous X/Twitter agents posting Web3 content.

```bash
git clone https://github.com/ChainGPT-org/AgenticOS.git && cd AgenticOS
bun install && bun start
```

> Full setup, env vars, webhook config, deployment: `reference/agenticos.md`

### 7. Solidity LLM (Open-Source)

2B-parameter model on HuggingFace (`Chain-GPT/Solidity-LLM`), MIT license. 83% compilation success rate.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Chain-GPT/Solidity-LLM").to("cuda")
tokenizer = AutoTokenizer.from_pretrained("Chain-GPT/Solidity-LLM")
```

> Full reference: `reference/solidity-llm.md`

## Project Scaffolding Templates

When a developer asks to scaffold a project, read the appropriate template file and generate the complete working starter code:

| Request | Template File |
|---------|--------------|
| "Build a Web3 AI chatbot" / "scaffold a chatbot app" | `templates/chatbot-app.md` |
| "Build an NFT minting service" / "NFT generation tool" | `templates/nft-minting-service.md` |
| "Set up contract auditing in CI/CD" / "audit pipeline" | `templates/contract-auditor-ci.md` |
| "Build a crypto news dashboard" / "news feed widget" | `templates/news-dashboard.md` |
| "Launch an AI Twitter agent" / "create a crypto bot" | `templates/twitter-agent.md` |
| "Combine multiple products" / "multi-product architecture" | `templates/composition-patterns.md` |

## Detailed Reference Files

When you need specifics beyond this quickstart, read the corresponding reference file:

| Topic | File |
|-------|------|
| LLM Chatbot — full API, context injection, tones, enums | `reference/llm-chatbot.md` |
| NFT Generator — all endpoints, models, styles, chains | `reference/nft-generator.md` |
| Smart Contract Generator — params, SDK, history | `reference/smart-contract-generator.md` |
| Smart Contract Auditor — audit params, SDK, report format | `reference/smart-contract-auditor.md` |
| Crypto News — categories, tokens, RSS feeds | `reference/crypto-news.md` |
| AgenticOS — setup, webhooks, deployment | `reference/agenticos.md` |
| Solidity LLM — model specs, training, benchmarks | `reference/solidity-llm.md` |
| SaaS & Whitelabel — launchpad, staking, vesting products | `reference/saas-whitelabel.md` |
| Pricing — complete credit costs across all products | `reference/pricing.md` |
| Error Codes — HTTP errors, SDK exceptions, troubleshooting | `reference/error-codes.md` |
| Product Selection — decision matrix, cost estimates by scale | `reference/product-selection.md` |
| Wallet Integration — MetaMask, WalletConnect, minting flows | `reference/wallet-integration.md` |
| Advanced Patterns — streaming, rate limiting, caching, circuit breaker | `reference/advanced-patterns.md` |
| Deployment — Vercel, Railway, Docker, AWS Lambda, CI/CD | `reference/deployment.md` |
| Cost Optimization — caching, batching, history toggle strategies | `reference/cost-optimization.md` |
| TypeScript Types — complete request/response interfaces | `reference/typescript-types.md` |

## Working Code Examples

Complete runnable examples are in the `examples/` directory:

- `examples/js/chatbot-stream.js` — Streaming chatbot with context injection
- `examples/js/nft-generate-mint.js` — Generate image + mint NFT on BSC
- `examples/js/audit-contract.js` — Audit a Solidity contract file
- `examples/js/fetch-news.js` — Fetch filtered crypto news
- `examples/python/chatbot_stream.py` — Async streaming chatbot
- `examples/python/nft_generate_mint.py` — Generate + mint NFT
- `examples/python/audit_contract.py` — Audit contract from file
- `examples/python/fetch_news.py` — Fetch and display news

## Credit Cost Estimator

**Before generating code that makes API calls, always estimate and report the credit cost to the developer.** Use this reference:

| Operation | Credits | USD |
|-----------|---------|-----|
| LLM Chat (single request) | 0.5 | $0.005 |
| LLM Chat + history | 1.0 | $0.01 |
| NFT Generate (VeloGen/Nebula/Visionary) | 1.0 | $0.01 |
| NFT Generate + 1x upscale | 2.0 | $0.02 |
| NFT Generate + 2x upscale | 3.0 | $0.03 |
| NFT Generate (Dale3 1024x1024) | 4.75 | $0.0475 |
| NFT Generate (Dale3 other resolutions) | ~9.5 | ~$0.095 |
| NFT Generate (Dale3 + enhanced) | ~14.25 | ~$0.1425 |
| NFT Generate (NebulaForge/VisionaryForge steps 26-50) | +0.25 surcharge | +$0.0025 |
| NFT Character Preserve | +5.0 | +$0.05 |
| NFT Prompt Enhancement | 0.5 | $0.005 |
| NFT Mint / Chains / ABI | 0 | Free |
| Contract Generator | 1.0 | $0.01 |
| Contract Generator + history | 2.0 | $0.02 |
| Contract Auditor | 1.0 | $0.01 |
| Contract Auditor + history | 2.0 | $0.02 |
| News (per 10 records) | 1.0 | $0.01 |
| AgenticOS (per tweet) | 1.0 | $0.01 |

**Example estimate:** "Generating 100 NFTs with NebulaForge XL + 1x upscale = 200 credits ($2.00). With prompt enhancement for each: 250 credits ($2.50)."

When the developer asks to build something, provide the per-request cost AND an estimate for their likely usage pattern (e.g., "At 1,000 chat requests/day, that's ~500 credits/day = $5/day").

## Smart Contract Patterns

When generating Solidity contracts, check the `patterns/` directory first. 45+ audited patterns available:
- `patterns/tokens.md` — 10 ERC-20 variants (basic, burnable, taxable, reflection, governance, etc.)
- `patterns/nfts.md` — 10 NFT patterns (ERC-721, 721A, lazy mint, soulbound, dynamic, ERC-1155, etc.)
- `patterns/defi.md` — 10 DeFi patterns (staking, vesting, bonding curve, AMM, flash loans, etc.)
- `patterns/governance.md` — 5 DAO patterns (Governor, multi-sig, treasury, delegation)
- `patterns/security.md` — 10 security patterns (access control, upgradeable, timelock, escrow, etc.)

Compose from these patterns rather than generating from scratch — they're audited and gas-optimized.

## Migration Guides

If a developer is migrating from another platform, read the relevant guide:
- `migration/from-openai.md` — OpenAI → ChainGPT (concept mapping, code migration, pricing comparison)
- `migration/from-alchemy.md` — Alchemy AI → ChainGPT (complementary + replacement strategies)
- `migration/from-custom.md` — Custom AI solutions → ChainGPT (cost comparison, hybrid approach)

## Additional Skills

These are Claude Code skill commands — invoke them in any Claude conversation, not in a terminal.

| Command | What It Does |
|---------|-------------|
| `/chaingpt-playground` | Interactively test any ChainGPT API endpoint live |
| `/chaingpt-debug` | Diagnose and fix ChainGPT API errors |
| `/chaingpt-hackathon` | Scaffold a complete hackathon project in 60 seconds |
| `/chaingpt-update` | Check for and apply skill updates |

## MCP Server

If the ChainGPT MCP server is installed, Claude can call ChainGPT APIs directly (not just generate code). 12 tools available — see `mcp-server/README.md`.

## Mock Server for Testing

A full mock server is available at `mock-server/` for development and CI/CD without spending credits. Mimics all endpoints with realistic responses. See `mock-server/README.md`.

## Key Conventions

When generating code that uses ChainGPT APIs, always:

1. **Store API keys in environment variables** — never hardcode. Use `process.env.CHAINGPT_API_KEY` (JS) or `os.environ["CHAINGPT_API_KEY"]` (Python).
2. **Handle credit exhaustion** — check for HTTP 402/403 and prompt the user to top up at https://app.chaingpt.org/addcredits.
3. **Use streaming for chat-based products** when building user-facing UIs — better UX than waiting for full response.
4. **Include error handling** — wrap SDK calls in try/catch with product-specific error classes (e.g., `Errors.GeneralChatError`, `Errors.NftError`).
5. **Use sdkUniqueId for multi-user apps** — isolates chat history per user/session.
6. **Prefer the SDK over raw REST** — handles auth, streaming, and error typing automatically.
7. **Estimate credit costs before batch operations** — always tell the developer what the operation will cost before running it.
8. **Use patterns for contracts** — check `patterns/` before generating Solidity from scratch.
9. **Use the mock server for testing** — point to `http://localhost:3001` during development to avoid spending credits.

## Links

- **API Dashboard:** https://app.chaingpt.org/apidashboard
- **Pricing:** https://app.chaingpt.org/pricing
- **Purchase Credits:** https://app.chaingpt.org/addcredits
- **Grant Program ($1M):** https://www.chaingpt.org/web3-ai-grant
- **Developer Docs:** https://docs.chaingpt.org/dev-docs-b2b-saas-api-and-sdk
- **Solidity LLM (HuggingFace):** https://huggingface.co/Chain-GPT/Solidity-LLM
- **AgenticOS (GitHub):** https://github.com/ChainGPT-org/AgenticOS
- **SaaS Demo Booking:** https://calendly.com/saaswl/demo