MegaLLM

https://docs.megallm.io/en/
Admin
MegaLLM is a universal AI platform that connects over 70 large language models through a single,...
Tokens:133,557
Snippets:989
Trust Score:6.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install and Use MegaLLM CLI

Source: https://docs.megallm.io/en/home/getting-started/quick-start

Instructions for installing the MegaLLM command-line interface tool using npm. Follow the interactive setup for configuration.

```bash
# Install MegaLLM CLI
npx megallm@latest

# Follow the interactive setup

```

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

### Set Up Project and Install Dependencies

Source: https://docs.megallm.io/en/home/getting-started/first-request

Instructions for setting up a new project directory and installing necessary libraries for MegaLLM integration. Supports both Python and Node.js environments.

```bash
# Create directory
mkdir my-first-ai-app
cd my-first-ai-app

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install openai python-dotenv
```

```bash
# Create directory
mkdir my-first-ai-app
cd my-first-ai-app

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv
```

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

### First-Time Setup Example

Source: https://docs.megallm.io/en/cli/overview

An example demonstrating the interactive prompts and output during the first-time setup of the MegaLLM CLI. It shows system detection, tool selection, API key input, and successful configuration confirmation. This example assumes a Linux environment with bash shell and Claude Code installed.

```bash
# Run the CLI
npx megallm@latest

# Interactive prompts:
# ✓ System detected: Linux (bash)
# ✓ Tools detected: Claude Code ✓, Codex ✗
#
# ? Which tool? › Claude Code
# ? Setup level? › System-level (global)
# ? Enter API key: sk-mega-***
#
# ✓ Configuration applied successfully!
# 🎉 Ready to use Claude Code with MegaLLM
```

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

### Install SDKs for MegaLLM Troubleshooting

Source: https://docs.megallm.io/en/home/getting-started/setup

Provides commands to install the necessary SDKs for Python and JavaScript to resolve 'Module not found' errors during MegaLLM setup verification.

```bash
pip install openai  # Python
```

```bash
npm install openai  # JavaScript
```

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

### Kilocode First-Time Installation Scenario

Source: https://docs.megallm.io/en/agents/kilocode

A step-by-step guide for first-time users to install and configure the Kilocode extension with MegaLLM. This includes installing the extension, obtaining an API key from MegaLLM, configuring the extension via settings.json, and testing the setup with a code completion example.

```json
{
  "kilocode.apiProvider": "custom",
  "kilocode.customProvider": {
    "name": "MegaLLM",
    "baseURL": "https://ai.megallm.io/v1",
    "apiKey": "sk-mega-your-actual-key-here"
  },
  "kilocode.defaultModel": "gpt-5"
}
```

```javascript
// function to calculate fibonacci
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}
```

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

### Install MegaLLM SDKs

Source: https://docs.megallm.io/en/home/getting-started/setup

Instructions for installing the necessary SDKs to interact with MegaLLM. This includes the recommended OpenAI SDK, the Anthropic SDK, and the python-dotenv library for environment variable management. Installation commands are provided for Python, JavaScript/TypeScript, and Go.

```bash
# OpenAI SDK (recommended)
pip install openai

# Or Anthropic SDK
pip install anthropic

# For environment variables
pip install python-dotenv

```

```bash
# OpenAI SDK (recommended)
npm install openai

# Or Anthropic SDK
npm install @anthropic-ai/sdk

# For environment variables
npm install dotenv

```

```bash
go get github.com/sashabaranov/go-openai

```

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

### Install OpenAI SDK for Python and JavaScript

Source: https://docs.megallm.io/en/home/getting-started/quick-start

Installs the necessary SDKs for interacting with the MegaLLM API in Python and JavaScript. Ensure you have pip or npm installed.

```bash
# Install OpenAI SDK
pip install openai
```

```bash
# Install OpenAI SDK
npm install openai
```

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

### Install Python SDKs for OpenAI or Anthropic

Source: https://docs.megallm.io/en/home/getting-started/overview

This snippet shows how to install the necessary Python SDKs for interacting with AI models. You can choose to install either the OpenAI or the Anthropic SDK, as MegaLLM provides compatibility with both.

```bash
pip install openai
# or
pip install anthropic
```

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

### Developer Onboarding Workflow with MegaLLM

Source: https://docs.megallm.io/en/cli/examples

Outlines the steps for a new developer to onboard onto a project using MegaLLM. This includes cloning the repository, obtaining an API key, running the MegaLLM setup CLI (with `NO_BANNER=1` for cleaner output), and starting development.

```bash
# 1. New developer clones the repository
git clone https://github.com/company/project.git
cd project

# 2. Sees MegaLLM setup instructions in README
cat README.md
# "Get your API key from https://megallm.io/dashboard"

# 3. Gets API key from dashboard
# Opens https://megallm.io/dashboard in browser

# 4. Runs setup (with NO_BANNER for cleaner output)
NO_BANNER=1 npx megallm@latest

# 5. Enters API key when prompted
# Configuration automatically merges with project settings

# 6. Starts developing
npm run dev
```

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

### Interactive CLI Setup (Bash)

Source: https://docs.megallm.io/en/cli/examples

Initiates the interactive command-line interface for MegaLLM setup. This is the primary method for configuring MegaLLM, guiding users through tool selection, setup level, and API key input. It supports various LLM providers and setup scopes.

```bash
# Run the interactive setup
npx megallm@latest

# Output:
#   __  __                _    _     __  __
#  |  \/  | ___  __ _  __ _| |   | |   |  \/  |
#  | |\/| |/ _ \/ _` |/ _` | |   | |   | |\/| |
#  | |  | |  __/ (_| | (_| | |___| |___| |  | |
#  |_|  |_|\___|\__, |\__,_|_____|_____|_|  |_|
#               |___/
#
# 🚀 MegaLLM CLI Setup Tool
# Supported: Claude Code, Codex/Windsurf, OpenCode
#
# ✓ System detected: Linux (bash)
# ✓ Tools detected: Claude Code ✓
#
# ? Which tool would you like to configure? Claude Code
# ? Setup level? System-level (global)
# ? Do you have a MegaLLM API key? Yes
# ? Enter your MegaLLM API key: sk-mega-***
#
# Configuration Summary:
# - Tool: Claude Code
# - Level: System-level
# - API Key: sk-mega-***86b9 (last 4 chars)
#
# ? Apply this configuration? Yes
#
# ✓ Configuration applied successfully!
# ✓ Shell reloaded
#
# 🎉 Setup complete! You can now use Claude Code with MegaLLM.

```

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

### Make First API Request (Go)

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

Make your first API call to the chat completions endpoint using Go. This example constructs an HTTP POST request with a JSON payload and authentication headers.

```go
package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "os"
)

func main() {
    payload := map[string]interface{}{
        "model": "gpt-4",
        "messages": []map[string]string{
            {
                "role": "user",
                "content": "Hello! Can you introduce yourself?",
            },
        },
        "max_tokens": 100,
    }

    body, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST",
        "https://ai.megallm.io/v1/chat/completions",
        bytes.NewBuffer(body))

    req.Header.Set("Authorization", "Bearer " + os.Getenv("MEGALLM_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}
```

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

### Initialize New Project for MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/setup

Steps to set up a new project for use with MegaLLM. This involves creating a project directory, initializing a Python virtual environment or a Node.js project, installing necessary packages (OpenAI SDK, python-dotenv), and creating a .env file for the API key, ensuring it's added to .gitignore.

```bash
mkdir my-ai-project
cd my-ai-project

```

```bash
# Python
python -m venv venv
source venv/bin/activate
pip install openai python-dotenv

# JavaScript
npm init -y
npm install openai dotenv

```

```bash
echo "MEGALLM_API_KEY=your-key-here" > .env
echo ".env" >> .gitignore

```

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

### Run MegaLLM CLI (NPX)

Source: https://docs.megallm.io/en/cli/overview

Execute the MegaLLM CLI to start the interactive setup wizard. This command requires Node.js and npm to be installed. It downloads and runs the latest version of the CLI without requiring a global installation.

```bash
npx megallm@latest
```

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

### OpenCode Setup Instructions (Markdown)

Source: https://docs.megallm.io/en/cli/opencode-config

These are setup instructions for OpenCode within a `README.md` file. They detail prerequisites, including obtaining a MegaLLM API key and installing OpenCode, and provide steps for setting the `MEGALLM_API_KEY` environment variable.

```markdown
# OpenCode Setup

## Prerequisites
1. Get MegaLLM API key from https://megallm.io/dashboard
2. Install OpenCode: `npm install -g opencode-ai`

## Setup
Set the MEGALLM_API_KEY environment variable:
```bash
export MEGALLM_API_KEY="your-api-key-here"
````

Add to your shell config (\.bashrc or \.zshrc) to make it permanent.

```

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

### Setup Instructions: Install Claude Code and Configure API Key

Source: https://docs.megallm.io/en/agents/claude

These instructions guide users on installing the Claude Code package via npm and setting up their API key either through a local configuration file or an environment variable.

```bash
npm install -g @anthropic-ai/claude-code
```

```json
{
  "env": {
    "ANTHROPIC_API_KEY": "your-key-here"
  }
}
```

```bash
export ANTHROPIC_API_KEY="your-key-here"
```

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

### Make First API Request (cURL)

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

Make your first API call to the chat completions endpoint using cURL. This example demonstrates how to send a request with model details, messages, and maximum token limit, including authentication.

```bash
curl https://ai.megallm.io/v1/chat/completions \
  -H "Authorization: Bearer $MEGALLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
            "model": "gpt-4",
            "messages": [
              {
                "role": "user",
                "content": "Hello! Can you introduce yourself?"
              }
            ],
            "max_tokens": 100
          }'
```

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

### Configure Python Client for MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/setup

Examples of configuring the Python client to connect to MegaLLM's API. It shows how to set the base URL and API key for both OpenAI and Anthropic compatible formats, and includes a test request to verify the connection.

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key=os.getenv("MEGALLM_API_KEY")
)

# Test the connection
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

```python
import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://ai.megallm.io",
    api_key=os.getenv("MEGALLM_API_KEY")
)

# Test the connection
message = client.messages.create(
    model="claude-3.5-sonnet",
    max_tokens=100,
    messages=[{"role": "user", "content": "Hello!"}]
)
print(message.content[0].text)

```

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

### Install and Run MegaLLM CLI (Global)

Source: https://docs.megallm.io/en/cli/overview

Install the MegaLLM CLI globally using npm for persistent access. After installation, you can run the `megallm` command from any directory to initiate the setup process. This is an alternative to using NPX.

```bash
npm install -g megallm
megallm
```

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

### Make First API Request (JavaScript)

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

Make your first API call to the chat completions endpoint using JavaScript's fetch API. This example demonstrates sending a POST request with necessary headers and a JSON body for the AI model.

```javascript
const response = await fetch("https://ai.megallm.io/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.MEGALLM_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "gpt-4",
    messages: [
      {
        role: "user",
        content: "Hello! Can you introduce yourself?"
      }
    ],
    max_tokens: 100
  })
});

const data = await response.json();
console.log(data);
```

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

### Claude Code Installation and Setup Instructions

Source: https://docs.megallm.io/en/cli/claude-config

Markdown document outlining prerequisites and setup steps for Claude Code, including obtaining an API key and installing the package via npm. It demonstrates creating a local configuration file or setting an environment variable.

```markdown
# MegaLLM Claude Code Setup

## Prerequisites
1. Get your MegaLLM API key from https://megallm.io/dashboard
2. Install Claude Code: `npm install -g @anthropic-ai/claude-code`

## Setup
1. Create `.claude/settings.local.json`:
   ```json
   {
     "env": {
       "ANTHROPIC_API_KEY": "your-key-here"
     }
   }
````

2. Or set environment variable:
   ```bash
   export ANTHROPIC_API_KEY="your-key-here"
   ```
```

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

### Initialize OpenAI Client with MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/overview

Demonstrates how to initialize the OpenAI client to use the MegaLLM API. By setting the `base_url` to MegaLLM's endpoint and providing your API key, you can seamlessly integrate with over 70 AI models.

```python
from openai import OpenAI

client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key="your-megallm-api-key"
)
```

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

### Configure JavaScript Client for MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/setup

Examples of configuring the JavaScript client to connect to MegaLLM's API. It demonstrates setting the baseURL and API key for both OpenAI and Anthropic compatible formats, including a sample request to confirm the connection.

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: process.env.MEGALLM_API_KEY
});

// Test the connection
const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello!' }]
});
console.log(response.choices[0].message.content);

```

```javascript
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  baseURL: 'https://ai.megallm.io',
  apiKey: process.env.MEGALLM_API_KEY
});

// Test the connection
const message = await client.messages.create({
  model: 'claude-3.5-sonnet',
  max_tokens: 100,
  messages: [{ role: 'user', content: 'Hello!' }]
});
console.log(message.content[0].text);

```

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

### Make Basic AI Request with MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/first-request

Demonstrates how to initialize the MegaLLM client and make a simple chat completion request. It shows how to load API keys from environment variables and process the response. Requires the 'openai' and 'python-dotenv' (Python) or 'openai' and 'dotenv' (Node.js) libraries.

```python
import os
from dotenv import load_dotenv
from openai import OpenAI

# Load environment variables
load_dotenv()

# Initialize client
client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key=os.getenv("MEGALLM_API_KEY")
)

# Make a request
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "What is MegaLLM?"}
    ]
)

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

```javascript
import OpenAI from 'openai';
import dotenv from 'dotenv';

// Load environment variables
dotenv.config();

// Initialize client
const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: process.env.MEGALLM_API_KEY
});

// Make a request
const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'user', content: 'What is MegaLLM?' }
  ]
});

// Print response
console.log(response.choices[0].message.content);
```

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

### Make API Call with Python

Source: https://docs.megallm.io/en/home/getting-started/quick-start

Demonstrates how to initialize the MegaLLM client and make a chat completion request using the OpenAI Python SDK. Replace 'your-megallm-api-key' with your actual API key.

```python
from openai import OpenAI

# Initialize client
client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key="your-megallm-api-key"  # Replace with your key
)

# Make a request
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "Say hello!"}
    ]
)

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

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

### Switch AI Models with Python and JavaScript

Source: https://docs.megallm.io/en/home/getting-started/first-request

Demonstrates how to iterate through different AI models (e.g., GPT-4, Claude, Gemini) and send a request to each. This allows for comparing model outputs or using the best model for a specific task. It requires the Megallm client to be initialized.

```python
models = ["gpt-4", "claude-3.5-sonnet", "gemini-2.5-pro"]

for model in models:
    print(f"\n--- Using {model} ---")
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "user", "content": "Explain quantum computing in one sentence."}
        ]
    )
    print(response.choices[0].message.content)
```

```javascript
const models = ['gpt-4', 'claude-3.5-sonnet', 'gemini-2.5-pro'];

for (const model of models) {
  console.log(`\n--- Using ${model} ---`);
  const response = await client.chat.completions.create({
    model: model,
    messages: [
      { role: 'user', content: 'Explain quantum computing in one sentence.' }
    ]
  });
  console.log(response.choices[0].message.content);
}
```

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

### Switching Between Different API Configurations

Source: https://docs.megallm.io/en/cli/examples

Demonstrates how to use different MegaLLM API configurations for separate projects. This involves navigating to the project directory and either re-running the setup or creating a custom `.claude/settings.json` file with specific API keys and base URLs.

```bash
# Project A: Use MegaLLM
cd ~/projects/project-a
npx megallm@latest
# Configure with MegaLLM API key

# Project B: Use different API
cd ~/projects/project-b
# Create custom configuration
cat > .claude/settings.json << 'EOF'
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://other-api.com",
    "ANTHROPIC_API_KEY": "other-key"
  }
}
EOF
```

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

### Docker Container Setup for MegaLLM

Source: https://docs.megallm.io/en/cli/examples

Provides a Dockerfile to set up a Node.js environment with the MegaLLM CLI installed globally. It configures the API key and base URL using environment variables and copies a local configuration file.

```dockerfile
FROM node:18

# Install MegaLLM CLI globally
RUN npm install -g megallm

# Set environment variables
ENV ANTHROPIC_BASE_URL=https://ai.megallm.io
ENV ANTHROPIC_API_KEY=your-key-here

# Create configuration directory
RUN mkdir -p /root/.claude

# Copy configuration file
COPY .claude/settings.json /root/.claude/settings.json

# Your app setup
WORKDIR /app
COPY . .
RUN npm install

CMD ["npm", "start"]
```

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

### Make First API Request (Python)

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

Make your first API call to the chat completions endpoint using Python's requests library. This example shows how to send a POST request with JSON payload, including authentication and model parameters.

```python
import requests
import os

response = requests.post(
    "https://ai.megallm.io/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.getenv('MEGALLM_API_KEY')}",
        "Content-Type": "application/json"
    },
    json={
        "model": "gpt-4",
        "messages": [
            {
                "role": "user",
                "content": "Hello! Can you introduce yourself?"
            }
        ],
        "max_tokens": 100
    }
)

print(response.json())
```

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

### Project-Specific Setup and Gitignore (Bash)

Source: https://docs.megallm.io/en/cli/examples

Configures MegaLLM for a specific project, creating local settings and adding them to .gitignore. This ensures API keys are not committed to version control. It involves navigating to the project directory, running the CLI, selecting project-level setup, and managing configuration files.

```bash
# Navigate to your project
cd ~/projects/my-app

# Run the CLI
npx megallm@latest

# Choose project-level setup
# ? Setup level?
#   System-level (global) - Applies to all projects
#   › Project-level (local) - Current directory only

# After configuration:
ls -la .claude/
# .claude/
#   settings.json
#   settings.local.json

# Add to .gitignore
echo ".claude/settings.local.json" >> .gitignore

# Commit project settings (without API key)
cat .claude/settings.json
# {
#   "env": {
#     "ANTHROPIC_BASE_URL": "https://ai.megallm.io"
#   }
# }

git add .claude/settings.json .gitignore
git commit -m "Add MegaLLM configuration"

```

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

### Configure API Base URL for OpenAI Format

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

Configure the base URL to use MegaLLM's OpenAI-compatible endpoints. Ensure your API key is also set.

```bash
export MEGALLM_BASE_URL="https://ai.megallm.io/v1"
export MEGALLM_API_KEY="your-api-key"
```

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

### RooCode Team Setup Markdown Guide

Source: https://docs.megallm.io/en/agents/roocode

This Markdown document provides step-by-step instructions for team members to set up RooCode using a shared configuration file. It covers prerequisites, importing the team configuration, adding personal API keys, and verification steps. It also includes a troubleshooting section for common issues.

```markdown
# RooCode Team Setup Guide

## Prerequisites
- RooCode application installed ([Download](https://roocode.io))
- MegaLLM API key ([Get yours](https://megallm.io/dashboard))

## Setup Steps

### 1. Get Your Personal API Key
1. Go to https://megallm.io/dashboard
2. Navigate to **API Keys**
3. Click **Create New Key**
4. Copy your key (starts with `sk-mega-`)

### 2. Import Team Configuration
1. Download `team-roocode-config.json` from this repo
2. Open RooCode
3. Go to: `File → Import Configuration`
4. Select `team-roocode-config.json`

### 3. Add Your Personal API Key
1. After import, go to: `Settings → API Configuration`
2. Replace `TEAM_MEMBER_REPLACES_THIS` with your actual key
3. Click **Test Connection** (should show ✓ Success)
4. Click **Save**

### 4. Restart RooCode
Close and reopen RooCode to apply all settings.

## Verification
1. Open a new chat
2. Type: `Generate a React component for a login form`
3. Should generate TypeScript code following Airbnb style

## Troubleshooting
- **Connection failed**: Check API key is correct
- **Wrong code style**: Verify configuration imported correctly
- **Model errors**: Ensure using `gpt-5` or other supported models

## Support
Contact team lead or check [MegaLLM Docs](https://docs.megallm.io)
```

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

### Make API Call with JavaScript

Source: https://docs.megallm.io/en/home/getting-started/quick-start

Shows how to set up the MegaLLM client and send a chat completion request using the OpenAI JavaScript SDK. Remember to replace 'your-megallm-api-key' with your valid API key.

```javascript
import OpenAI from 'openai';

// Initialize client
const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: 'your-megallm-api-key' // Replace with your key
});

// Make a request
const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'user', content: 'Say hello!' }
  ]
});

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

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

### Update Existing Project to Use MegaLLM

Source: https://docs.megallm.io/en/home/getting-started/setup

Instructions for integrating MegaLLM into an existing project that already uses the OpenAI or Anthropic SDKs. The primary change involves updating the client configuration to point to MegaLLM's base URL.

```python
# Before
client = OpenAI(api_key="sk-...")

# After
client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key="your-megallm-key"
)

```

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

### Install Node.js on Windows with Chocolatey

Source: https://docs.megallm.io/en/cli/installation

Install Node.js on Windows using the Chocolatey package manager.

```powershell
choco install nodejs
```

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

### Maintain Conversation Context

Source: https://docs.megallm.io/en/home/getting-started/first-request

Shows how to manage conversation history to enable multi-turn interactions with the AI. This involves appending system, user, and assistant messages to a list before making subsequent requests. Both Python and JavaScript examples are provided.

```python
import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key=os.getenv("MEGALLM_API_KEY")
)

# Conversation history
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is Python?"}
]

# First response
response = client.chat.completions.create(
    model="gpt-4",
    messages=messages
)

# Add to history
assistant_message = response.choices[0].message.content
messages.append({"role": "assistant", "content": assistant_message})
print(f"Assistant: {assistant_message}\n")

# Follow-up question
messages.append({"role": "user", "content": "What are its key features?"})

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages
)

print(f"Assistant: {response.choices[0].message.content}")
```

```javascript
import OpenAI from 'openai';
import dotenv from 'dotenv';

dotenv.config();

const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: process.env.MEGALLM_API_KEY
});

// Conversation history
const messages = [
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'What is JavaScript?' }
];

// First response
let response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: messages
});

// Add to history
const assistantMessage = response.choices[0].message.content;
messages.push({ role: 'assistant', content: assistantMessage });
console.log(`Assistant: ${assistantMessage}\n`);

// Follow-up question
messages.push({ role: 'user', content: 'What are its key features?' });

response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: messages
});

console.log(`Assistant: ${response.choices[0].message.content}`);
```

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

### CI/CD Installation with GitHub Actions

Source: https://docs.megallm.io/en/cli/installation

Sets up a Node.js environment and runs the MegaLLM CLI within a GitHub Actions workflow. It uses the `actions/setup-node` action to configure the Node.js version and then executes `npx` to run the CLI.

```yaml
- name: Setup Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18'

- name: Run MegaLLM CLI
  run: npx megallm@latest
  env:
    NO_BANNER: '1'
```

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

### Handle API Errors with Python and JavaScript

Source: https://docs.megallm.io/en/home/getting-started/first-request

Provides examples of how to implement error handling for API requests. It specifically catches common issues like authentication errors and rate limit exceeded errors, as well as general exceptions. This ensures graceful failure and informative messages to the user. Both Python and JavaScript versions are provided.

```python
from openai import OpenAI, AuthenticationError, RateLimitError

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

except AuthenticationError:
    print("<Icon icon=\"xmark\" /> Invalid API key")
except RateLimitError:
    print("<Icon icon=\"xmark\" /> Rate limit exceeded")
except Exception as e:
    print(f"<Icon icon=\"xmark\" /> Error: {e}")
```

```javascript
try {
  const response = await client.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: 'Hello!' }]
  });
  console.log(response.choices[0].message.content);

} catch (error) {
  if (error.status === 401) {
    console.log('<Icon icon="xmark" /> Invalid API key');
  } else if (error.status === 429) {
    console.log('<Icon icon="xmark" /> Rate limit exceeded');
  } else {
    console.log(`<Icon icon="xmark" /> Error: ${error.message}`);
  }
}
```

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

### Build Interactive Chatbot with Python and JavaScript

Source: https://docs.megallm.io/en/home/getting-started/first-request

Demonstrates how to create a simple command-line chatbot. It maintains conversation history and sends it with each new user message to the AI. The examples include setting up the client with an API key and base URL, and handling user input in a loop. Both Python and JavaScript versions are provided for building interactive chat experiences.

```python
import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
    base_url="https://ai.megallm.io/v1",
    api_key=os.getenv("MEGALLM_API_KEY")
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."}
]

print("Chat with AI (type 'quit' to exit)\n")

while True:
    user_input = input("You: ")

    if user_input.lower() == 'quit':
        break

    messages.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

    assistant_message = response.choices[0].message.content
    messages.append({"role": "assistant", "content": assistant_message})

    print(f"AI: {assistant_message}\n")
```

```javascript
import OpenAI from 'openai';
import dotenv from 'dotenv';
import readline from 'readline';

dotenv.config();

const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: process.env.MEGALLM_API_KEY
});

const messages = [
  { role: 'system', content: 'You are a helpful assistant.' }
];

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

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

function chat() {
  rl.question('You: ', async (userInput) => {
    if (userInput.toLowerCase() === 'quit') {
      rl.close();
      return;
    }

    messages.push({ role: 'user', content: userInput });

    const response = await client.chat.completions.create({
      model: 'gpt-4',
      messages: messages
    });

    const assistantMessage = response.choices[0].message.content;
    messages.push({ role: 'assistant', content: assistantMessage });

    console.log(`AI: ${assistantMessage}\n`);
    chat();
  });
}

chat();
```

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

### Chat Completions API Endpoint

Source: https://docs.megallm.io/en/dev-docs/getting-started/quick-start

This endpoint allows you to get chat completions from the MegaLLM API. You can use it with different models and provide a conversation history.

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

### Description
This endpoint enables users to interact with the chat completion model to generate conversational responses.

### Method
POST

### Endpoint
/v1/chat/completions

### Parameters
#### Query Parameters
None

#### Request Body
- **model** (string) - Required - The model to use for chat completions (e.g., "gpt-4").
- **messages** (array) - Required - A list of message objects representing the conversation history.
  - **role** (string) - Required - The role of the author of the message (e.g., "user", "assistant", "system").
  - **content** (string) - Required - The content of the message.
- **max_tokens** (integer) - Optional - The maximum number of tokens to generate in the completion.

### Request Example
```json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "user",
      "content": "Hello! Can you introduce yourself?"
    }
  ],
  "max_tokens": 100
}
```

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the chat completion.
- **object** (string) - The type of object returned, usually "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) - The index of the choice.
  - **message** (object) - The message content from the assistant.
    - **role** (string) - The role of the message author, usually "assistant".
    - **content** (string) - The generated content of the message.
  - **finish_reason** (string) - The reason the model stopped generating tokens (e.g., "stop").
- **usage** (object) - Information about token usage.
  - **prompt_tokens** (integer) - The number of tokens in the prompt.
  - **completion_tokens** (integer) - The number of tokens in the completion.
  - **total_tokens** (integer) - The total number of tokens used.

#### Response Example
```json
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I'm an AI assistant powered by MegaLLM..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 25,
    "total_tokens": 35
  }
}
```
```

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

### System-Level Manual Setup for OpenCode (Bash)

Source: https://docs.megallm.io/en/cli/opencode-config

Provides a bash script to manually set up OpenCode system-level configuration. It creates the configuration directory, writes the opencode.json file, sets the MEGALLM_API_KEY environment variable, and verifies the configuration using jq.

```bash
# 1. Create directory
mkdir -p ~/.config/opencode

# 2. Create config file
cat > ~/.config/opencode/opencode.json << 'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "apiKey": "{env:MEGALLM_API_KEY}",
        "baseURL": "https://ai.megallm.io/v1"
      }
    }
  },
  "autoupdate": true,
  "tools": {
    "bash": true,
    "edit": true,
    "write": true,
    "read": true
  }
}
EOF

# 3. Set environment variable
echo 'export MEGALLM_API_KEY="your-api-key"' >> ~/.bashrc
source ~/.bashrc

# 4. Verify
cat ~/.config/opencode/opencode.json | jq .
```

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

### Complete OpenCode Configuration Example (JSON)

Source: https://docs.megallm.io/en/cli/opencode-config

A comprehensive example of an OpenCode JSON configuration file, combining provider settings (including multiple models), API options, tool configurations, and autoupdate settings.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "models": {
        "gpt-5": {
          "id": "gpt-5",
          "name": "GPT-5 (Via MegaLLM)"
        },
        "gpt-4": {
          "id": "gpt-4",
          "name": "GPT-4 (Via MegaLLM)"
        },
        "claude-sonnet-4": {
          "id": "claude-sonnet-4",
          "name": "Claude Sonnet 4 (Via MegaLLM)"
        }
      },
      "options": {
        "apiKey": "{env:MEGALLM_API_KEY}",
        "baseURL": "https://ai.megallm.io/v1"
      }
    }
  },
  "autoupdate": true,
  "tools": {
    "bash": true,
    "edit": true,
    "write": true,
    "read": true
  }
}
```

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

### API Response Structure (JSON)

Source: https://docs.megallm.io/en/home/getting-started/first-request

This JSON object represents a typical response from the chat completion API. It includes details about the request ID, model used, creation timestamp, choices with assistant messages, and token usage statistics.

```json
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}
```

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

### Claude Code System Configuration and Environment Variables

Source: https://docs.megallm.io/en/agents/overview

Demonstrates system-level setup for Claude Code, including the location of its settings file and the necessary environment variables for API access. This pattern is suitable for personal use on a single machine.

```bash
# System configuration
~/.claude/settings.json

# Environment variables
export ANTHROPIC_BASE_URL="https://ai.megallm.io"
export ANTHROPIC_API_KEY="sk-mega-your-key"
```

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

### Project-Level Manual Setup for OpenCode (Bash)

Source: https://docs.megallm.io/en/cli/opencode-config

A bash script for manually setting up project-level OpenCode configuration. It navigates to the project directory, creates opencode.json, optionally sets the API key environment variable, and adds the config file to .gitignore.

```bash
# 1. Navigate to project
cd ~/projects/my-project

# 2. Create config file
cat > opencode.json << 'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "apiKey": "{env:MEGALLM_API_KEY}",
        "baseURL": "https://ai.megallm.io/v1"
      }
    }
  },
  "tools": {
    "bash": true,
    "edit": true,
    "write": true,
    "read": true
  }
}
EOF

# 3. Set environment variable (if not already set)
echo 'export MEGALLM_API_KEY="your-api-key"' >> ~/.bashrc
source ~/.bashrc

# 4. Add to .gitignore
echo "opencode.json" >> .gitignore
```

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

### Setting Project-Specific API Keys with MegaLLM

Source: https://docs.megallm.io/en/cli/faq

Provides examples of how to configure different API keys for separate projects by navigating to each project's directory and running the MegaLLM CLI. This creates project-level configuration files.

```bash
# Project A
cd ~/projects/project-a
npx megallm@latest
# Choose: Project-level
# Enter API key for Project A

# Project B
cd ~/projects/project-b
npx megallm@latest
# Choose: Project-level
# Enter API key for Project B
```

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

### Customize AI Responses with Parameters in Python

Source: https://docs.megallm.io/en/home/getting-started/first-request

Shows how to adjust the output of the AI model by providing various parameters. These parameters include temperature for creativity, max_tokens for response length, top_p for nucleus sampling, and frequency_penalty to reduce repetition. This snippet uses Python and assumes the Megallm client is already set up.

```python
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "Write a short poem about AI"}
    ],
    temperature=0.9,      # Higher = more creative
    max_tokens=100,       # Limit response length
    top_p=0.95,          # Nucleus sampling
    frequency_penalty=0.5 # Reduce repetition
)
```

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

### View Available NPM Package Versions

Source: https://docs.megallm.io/en/cli/installation

Lists all published versions of an NPM package from the registry. This command helps in identifying which versions are available for installation or use.

```bash
# View all available versions
npm view megallm versions

# View latest version
npm view megallm version
```

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

### Prefill Assistant Response in Python

Source: https://docs.megallm.io/en/dev-docs/anthropic/messages

This Python example shows how to prefill the assistant's response when creating a message. By including a message with the role 'assistant' and some initial content, you can guide the beginning of the model's output. This is useful for setting a specific format or starting point for the AI's generated text. The `client.messages.create` method is used with the modified message list.

```Python
messages = [
    {"role": "user", "content": "Write a haiku about programming"},
    {"role": "assistant", "content": "Here's a haiku about programming:\n\n"}  # Prefill
]

response = client.messages.create(
    model="claude-3.5-sonnet",
    max_tokens=50,
    messages=messages
)

# The response will continue from the prefilled content
```

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

### Troubleshoot MegaLLM CLI Permission Denied Error

Source: https://docs.megallm.io/en/cli/examples

This example addresses a 'Permission Denied' error encountered during the MegaLLM CLI setup, often related to directory creation. The solution involves adjusting file permissions for the `.claude` and `.codex` directories using `chown` and `chmod` commands. After fixing permissions, retry the setup.

```bash
# Error during setup
npx megallm@latest
# Error: EACCES: permission denied, mkdir '/home/user/.claude'

# Fix permissions
sudo chown -R $USER ~/.claude ~/.codex
chmod -R 755 ~/.claude ~/.codex

# Retry
npx megallm@latest
```

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

### Install Node.js and npm for 'npm: command not found'

Source: https://docs.megallm.io/en/cli/troubleshooting

This section provides commands to install Node.js and npm, which are prerequisites for using the MegaLLM CLI. It includes platform-specific instructions for macOS and Linux, and directs Windows users to the official Node.js website. Verification commands are also provided.

```bash
# Using Homebrew
brew install node

# Or download from nodejs.org
```

```bash
# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# Fedora
sudo dnf install nodejs
```

```bash
node --version
npm --version
```

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

### Verify MegaLLM Setup with JavaScript

Source: https://docs.megallm.io/en/home/getting-started/setup

Tests the MegaLLM API connection and configuration using JavaScript (Node.js). It verifies the API key environment variable and performs a basic chat completion request.

```javascript
import OpenAI from 'openai';

// Check API key
const apiKey = process.env.MEGALLM_API_KEY;
if (!apiKey) {
  console.log('❌ API key not set!');
  process.exit(1);
}
console.log('✅ API key found');

// Test connection
const client = new OpenAI({
  baseURL: 'https://ai.megallm.io/v1',
  apiKey: apiKey
});

try {
  const response = await client.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: "Say 'Setup successful!'" }],
    max_tokens: 10
  });
  console.log('✅ Connection successful!');
  console.log(`Response: ${response.choices[0].message.content}`);
} catch (error) {
  console.log(`❌ Error: ${error.message}`);
}
```

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

### Docker Installation of NPM Packages

Source: https://docs.megallm.io/en/cli/installation

Includes instructions for installing NPM packages globally within a Dockerfile, using either `npm install -g` or `npx`. It demonstrates setting up a Node.js environment and configuring the container's default command.

```dockerfile
FROM node:18

# Install megallm globally
RUN npm install -g megallm

# Or use npx
RUN npx megallm@latest --version

# Configure at runtime
CMD ["megallm"]
```
Tokens:
Raw