302.AI API Integration Assistant

Quickly help users find and integrate any of 302.AI's 1400+ APIs into their code.

Description

This is a specialized assistant for 302.AI API integration. When users need AI capabilities in their projects, this Skill will:

Automatically search 302.AI's API list to find the most suitable API
Retrieve detailed API documentation and usage instructions
Generate integration code based on user's programming language
Configure code with user's API Key

Trigger Conditions

IMPORTANT: Use this skill proactively whenever user mentions:

Any AI functionality (LLM, image generation, video generation, audio processing, etc.)
Specific AI models (GPT-4, Claude, DALL-E, Stable Diffusion, etc.)
API needs or integration requirements
302.AI or any AI service
Text processing, image editing, video creation, speech recognition, etc.

Workflow

Step 1: Get API Key

Before starting, must obtain user's 302.AI API Key:

To help you integrate 302.AI APIs, I need your API Key.

Please provide your 302.AI API Key (unified for all APIs):

Important:

All 302.AI APIs use a unified API Key
Must ask if user hasn't provided it
API Key format usually starts with sk-

Step 2: Understand User Requirements

Analyze what functionality user wants to implement and determine which API category is needed. Reference API categories:

1. Language Models (LLM)

Chat, text generation, code generation, translation, summarization, etc.
Includes: OpenAI, Claude, Gemini, Chinese models, etc.

2. Image Generation

Text-to-image, image-to-image, AI painting, etc.
Includes: DALL-E, Midjourney, Stable Diffusion, Flux, etc.

3. Image Processing

Image editing, background removal, super-resolution, style transfer, 3D generation, etc.
Includes: Basic features, advanced features, ComfyUI workflows

4. Video Generation

Text-to-video, image-to-video, digital humans, etc.
Includes: Runway, Pika, Luma AI, Kling, etc.

5. Audio/Video Processing

TTS (text-to-speech), STT (speech-to-text), music generation, audio processing

6. Information Processing

Search services, document processing, web scraping, social media, code execution

7. RAG Related

Embeddings, Rerank, knowledge base

8. Tool APIs

Creative tools, writing tools, professional tools

9. Management Functions

Account management, usage statistics

Step 3: Search APIs

⚠️ CRITICAL: Use the parse script, DO NOT read llms.txt directly

To reduce context usage, MUST use the scripts/parse_api_list.py script via Bash:

Bash Command Usage:

# Search by keyword
python3 scripts/parse_api_list.py "keyword"

# Search by keyword and category
python3 scripts/parse_api_list.py "keyword" "category"

# Examples:
python3 scripts/parse_api_list.py "GPT"
python3 scripts/parse_api_list.py "image generation"
python3 scripts/parse_api_list.py "chat" "language model"
python3 scripts/parse_api_list.py "nano-banana"

Python Module Usage (if needed):

from scripts.parse_api_list import fetch_llms_txt, parse_llms_txt, search_apis, extract_doc_id

# Auto-fetch latest API list
content = fetch_llms_txt()

# Parse API list
apis = parse_llms_txt(content)

# Search based on user needs (supports keyword and category filtering)
results = search_apis(apis, keyword='user_keyword', category='category')

# Display results for user selection
for i, api in enumerate(results, 1):
    print(f"{i}. {api['name']}")
    print(f"   Category: {api['category']}")
    print(f"   Description: {api['description']}")
    print(f"   Docs: {api['link']}")

⚠️ CRITICAL RULES (MUST FOLLOW):

ALWAYS use the script to search APIs, don't be lazy!
FORBIDDEN to use WebFetch to directly read llms.txt, this wastes massive context
Script automatically fetches the latest API list
Note: /v1/models endpoint only lists LLM language models, NOT image/video/audio models
If user needs image generation, video generation, audio processing, etc., MUST use script to search llms.txt for corresponding APIs

For detailed usage, refer to references/parse_script_usage.md.

Step 4: Search and Filter APIs

Based on user needs and Step 2 categories, search for matching APIs in the API list:

Filter by category: First locate the major category and subcategory
Keyword matching: Search for relevant keywords in descriptions
Model matching: If user specifies a specific model (like GPT-4), match directly

Step 5: Display Candidate APIs

Show found APIs to user for selection:

I found the following available APIs:

1. **OpenAI Chat**
   - Category: Language Models > OpenAI
   - Description: Supports GPT-4, GPT-3.5 and other chat models
   - Docs: https://doc.302.ai/147522039e0.md

2. **Claude Chat**
   - Category: Language Models > Claude
   - Description: Supports Claude 3.5 Sonnet, Claude 3 Opus and other models
   - Docs: https://doc.302.ai/xxxxxxxxx.md

Please select the API you want to use (enter number):

Step 6: Get Detailed Documentation

After user selection, use WebFetch to get detailed API documentation:

WebFetch(
    url="[user_selected_api_doc_link]",
    prompt="Extract API endpoint, request parameters, response format, usage examples and other detailed information"
)

Step 7: Generate Integration Code

Generate complete integration code based on:

User's programming language (ask user or infer from context)
API detailed documentation (from Step 6)
User's API Key (from Step 1)
User's specific requirements (e.g., parameter configuration, feature customization)

Reference code templates in references/integration_examples.md, generate code including:

Complete API call function
Correct endpoint URL
Required request headers (including API Key)
Request parameter examples
Error handling
Usage examples

Supported Programming Languages:

Python
JavaScript/Node.js
TypeScript
Go
cURL commands
Others (based on user needs)

Step 8: Code Explanation and Optimization Suggestions

After generating code, provide:

Code explanation: Explain key parts
Parameter explanation: List configurable parameters and their meanings
Usage examples: Show how to call the generated functions
Important notes:
- API Key security (recommend using environment variables)
- Rate limits
- Error handling
- Timeout settings
Optimization suggestions: Provide performance optimization suggestions based on user scenario

Code Generation Standards

Python Code Standard

import requests
import json

# 302.AI API Configuration
API_KEY = "{user_API_KEY}"
BASE_URL = "https://api.302.ai"

def call_api(endpoint, data):
    """
    Call 302.AI API

    Args:
        endpoint: API endpoint
        data: Request data

    Returns:
        API response result
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    url = f"{BASE_URL}{endpoint}"

    try:
        response = requests.post(url, headers=headers, json=data)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"API call failed: {e}")
        return None

# Usage example
if __name__ == "__main__":
    result = call_api("/v1/chat/completions", {
        "model": "gpt-4",
        "messages": [
            {"role": "user", "content": "Hello!"}
        ]
    })

    if result:
        print(json.dumps(result, indent=2, ensure_ascii=False))

JavaScript Code Standard

const axios = require('axios');

// 302.AI API Configuration
const API_KEY = '{user_API_KEY}';
const BASE_URL = 'https://api.302.ai';

async function callAPI(endpoint, data) {
    try {
        const response = await axios.post(`${BASE_URL}${endpoint}`, data, {
            headers:

302ai-api-integration