Stop Paying for Multiple AI Subscriptions! Use easy-llm-cli Instead

Stop Paying for Multiple AI Subscriptions! Use easy-llm-cli Instead

What if one command could unlock every AI model on Earth? No more juggling ChatGPT, Claude, Gemini, and DeepSeek tabs. No more bleeding money on redundant subscriptions. Developers are quietly abandoning the "one-model-per-platform" trap—and they're using a weapon you probably haven't discovered yet.

Here's the painful truth: you're burning hours context-switching between AI tools that can't talk to your codebase. You paste code into ChatGPT, lose formatting, forget the file structure, and get generic answers that ignore your actual architecture. Meanwhile, your terminal sits there—powerful, local, ignored—while you click through browser tabs like it's 2019.

What if your command line became the AI? What if you could query Gemini for multimodal tasks, Claude for complex reasoning, and your local DeepSeek model for privacy—all from the same interface, with the same workflow, with zero context loss?

Enter easy-llm-cli: the open-source AI agent that shattered vendor lock-in. Forked from Google's Gemini CLI but liberated from Google's ecosystem, this tool connects to 15+ LLM providers including OpenAI, Claude, Grok, DeepSeek, Qwen, Kimi, and any OpenAI-compatible API. It's not just another CLI wrapper. It's a code-native AI operating system that understands your repositories, executes tools, and switches between brain-grade models as easily as you switch Git branches.

The secret's out. Top developers are already using it. And in the next 10 minutes, you'll understand exactly why they're never going back.

What is easy-llm-cli?

easy-llm-cli is an open-source command-line AI workflow tool created by ConardLi as a forked, liberated version of Google's Gemini CLI. While Google's original tool locked you into Gemini's ecosystem, ConardLi's fork explodes those walls—transforming a single-vendor utility into a universal AI gateway.

The project lives at ConardLi/easy-llm-cli and represents a growing rebellion against AI vendor lock-in. Its core mission? Let developers use any LLM they want without rewriting workflows, relearning interfaces, or rearchitecting prompts.

Why It's Trending Now

The timing is explosive. In 2024-2025, developers face a model fragmentation crisis:

• Gemini 2.5 Pro dominates multimodal tasks but lacks in coding depth
• Claude Sonnet 4 excels at complex reasoning but costs premium rates
• DeepSeek-R1 offers insane value but needs local deployment expertise
• Grok-4 brings X-data integration no competitor matches
• Qwen3-Plus and Doubao-Seed-1.6 crush it for Chinese-language codebases

Switching between them meant maintaining separate accounts, APIs, and mental models. easy-llm-cli collapses this chaos into one terminal command: elc.

The repository's comprehensive testing matrix—spanning 15 models across 8 providers—proves this isn't marketing fluff. Real tests. Real capabilities. Real transparency about what works (and what doesn't). That honesty is rare, and developers are responding.

Key Features That Destroy the Competition

🔓 Universal LLM Provider Support

Connect to any OpenAI-compatible API endpoint instantly. Google Gemini, OpenAI GPT-4.1, Anthropic Claude, xAI Grok, DeepSeek, Qwen, Kimi, Doubao, and local vLLM/Ollama deployments—all through identical environment variables. Switch providers by changing 4 lines in your shell config, not your entire toolchain.

🧠 Massive Context Window Operations

Query and edit entire codebases with LLMs that support large context windows. No more "please analyze this one file" gymnastics. Point easy-llm-cli at a 100,000-line repository and ask: "Find the memory leak in our WebSocket handler." It sees everything.

🖼️ Multimodal Code Generation

Generate complete applications from PDFs, sketches, and screenshots. Describe a UI in a hand-drawn wireframe, feed it to Gemini 2.5 Pro through easy-llm-cli, and receive production React^{↗ Bright Coding Blog} code. This isn't future-tech—it's in the test matrix with a ✅ right now.

🔧 MCP Server Integration

Model Context Protocol (MCP) servers extend easy-llm-cli with custom capabilities. Connect to databases, visualization libraries, enterprise tools, or internal APIs. The tool becomes a universal adapter between your AI brain and your infrastructure.

⚡ Operational Task Automation

Query GitHub pull requests, handle complex Git rebases, generate changelogs from commit history, create slide decks from git logs—all from natural language commands. Your terminal becomes a DevOps^{↗ Bright Coding Blog} automation engine.

🛡️ Local-First Privacy

Run fully local models via vLLM or Ollama. No data leaves your machine. For regulated industries, this isn't optional—it's existential. easy-llm-cli makes local deployment as simple as cloud APIs.

Use Cases: Where easy-llm-cli Absolutely Dominates

1. The Polyglot Codebase Archaeologist

You're inheriting a 5-year-old microservices monstrosity. No documentation. Original developers gone. Normally: weeks of pain. With easy-llm-cli:

> Describe the main pieces of this system's architecture.
> What security mechanisms are in place?
> Find all hardcoded secrets and generate a remediation plan.

The tool ingests the entire repository context and answers like an architect who built it. Claude Sonnet 4's chain-of-thought reasoning traces through call graphs you didn't know existed.

2. The Multimodal Prototype Machine

Your designer hands you a sketch. "Build this." Old workflow: translate sketch to specs, specs to tickets, tickets to code. New workflow:

> Generate a React dashboard from this screenshot with real-time data fetching

Gemini 2.5 Pro's multimodal capabilities—verified ✅ in testing—turn images into functional prototypes. Hours become minutes.

3. The CI/CD Automation Engineer

Every sprint ends with the same drudgery: changelog compilation, release notes, dependency updates. Automate it:

> Make me a slide deck showing the git history from the last 7 days, grouped by feature and team member.
> Generate release notes from commits since v2.3.0, highlighting breaking changes.

MCP servers connect to your GitHub, Jira, and Confluence. The AI executes across systems, not just suggests.

4. The Privacy-First AI Adopter

Your fintech startup can't send code to OpenAI. Regulatory nightmare. Solution: local DeepSeek-R1 via vLLM:

export USE_CUSTOM_LLM=true
export CUSTOM_LLM_ENDPOINT="http://localhost:8000/v1"
export CUSTOM_LLM_MODEL_NAME="deepseek-r1-32b"

Same workflow. Same power. Zero external data exposure. The test matrix confirms DeepSeek-R1-32B handles tool calling, complex tasks, and token counting locally.

Step-by-Step Installation & Setup Guide

Prerequisites

Easy-llm-cli requires Node.js 20 or higher. Verify your version:

node --version  # Must output v20.x.x or higher

If outdated, install from nodejs.org or use a version manager:

# Using nvm (recommended)
nvm install 20
nvm use 20

Quick Start (No Installation)

Test instantly without global installation:

npx easy-llm-cli

This downloads and runs the latest version. Perfect for evaluation, CI pipelines, or ephemeral environments.

Global Installation (Recommended)

For daily use, install globally and unlock the elc command:

npm install -g easy-llm-cli

Verify installation:

elc --version

Provider Configuration

Option A: Google Gemini (Default)

Set your Gemini API key:

export GEMINI_API_KEY="your-gemini-key-here"

Option B: Custom LLM (The Power Move)

Configure any OpenAI-compatible provider. Here's a complete production setup:

# Enable custom LLM mode
export USE_CUSTOM_LLM=true

# Core connection parameters
export CUSTOM_LLM_PROVIDER="openai"           # Provider identifier for logging
export CUSTOM_LLM_API_KEY="sk-your-key-here"  # Your actual API key
export CUSTOM_LLM_ENDPOINT="https://api.openai.com/v1"  # Base URL
export CUSTOM_LLM_MODEL_NAME="gpt-4.1"        # Specific model deployment

# Optional: Fine-tune generation behavior
export CUSTOM_LLM_TEMPERATURE=0.7   # Creativity vs determinism (0 = focused, 1 = creative)
export CUSTOM_LLM_MAX_TOKENS=8192   # Response length ceiling
export CUSTOM_LLM_TOP_P=1           # Nucleus sampling threshold

Pro tip: Store these in your shell profile (~/.zshrc, ~/.bashrc) or use a tool like direnv for per-project configuration. Switch between providers instantly by swapping environment files.

Option C: Local Deployment (vLLM/Ollama)

For air-gapped or privacy-critical environments:

export USE_CUSTOM_LLM=true
export CUSTOM_LLM_PROVIDER="local-vllm"
export CUSTOM_LLM_API_KEY="not-needed-for-local"
export CUSTOM_LLM_ENDPOINT="http://localhost:8000/v1"
export CUSTOM_LLM_MODEL_NAME="Qwen2.5-7B-Instruct"

Start your local server (vLLM example):

python↗ Bright Coding Blog -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-7B-Instruct \
  --port 8000

REAL Code Examples From the Repository

The easy-llm-cli repository doesn't just promise—it proves with executable patterns. Here are the actual implementations, extracted and explained.

Example 1: Launching a Project From Scratch

The README demonstrates starting a new project with natural language. Here's the exact pattern:

# Navigate to your target directory
cd new-project/

# Start the AI agent
elc

# Inside the interactive session, describe your goal:
# > Write me a Discord bot that answers questions using a FAQ.md file I will provide

What's happening under the hood? easy-llm-cli initializes a session context in new-project/, scans for existing files, and maintains conversation state. The LLM receives your project structure as system context, generating code that fits your actual environment—not generic snippets. When you mention FAQ.md, it creates the file reference, reads it when provided, and implements parsing logic specific to your format.

Example 2: Analyzing Existing Codebases

This pattern shows how easy-llm-cli ingests real repositories:

# Clone any repository
git clone https://github.com/ConardLi/easy-llm-cli
cd easy-llm-cli

# Launch with full codebase context
elc

# Query recent development activity:
# > Give me a summary of all of the changes that went in yesterday

The technical magic: easy-llm-cli executes git log --since="yesterday" --pretty=format:"%h %s" and similar commands automatically, feeds raw commit data to the LLM, and synthesizes human-readable summaries. But it goes deeper—it can correlate commits with modified files, identify which modules changed, flag potential breaking changes, and suggest review priorities. This isn't git log with GPT lipstick; it's structural code comprehension.

Example 3: Programmatic Integration (The Secret Weapon)

The most powerful pattern hides in the programmatic API. Here's the exact code from the repository:

// Import the agent class from the npm package
import { ElcAgent } from 'easy-llm-cli';

// Initialize with complete configuration
const agent = new ElcAgent({
  // Model identification for routing and capability detection
  model: 'custom-llm-model-name',
  
  // Authentication credential
  apiKey: 'custom-llm-api-key',
  
  // API endpoint—supports any OpenAI-compatible server
  endpoint: 'custom-llm-endpoint',
  
  // Extension configuration for advanced capabilities
  extension: {
    // MCP servers extend the agent with external tools
    mcpServers: {
      chart: {
        // Command to launch the MCP server
        command: 'npx',
        // Arguments passed to the command
        args: ['-y', '@antv/mcp-server-chart'],
        // Security: require user confirmation before execution
        trust: false
      }
    },
    // Explicitly disable dangerous tools for this instance
    excludeTools: ['run_shell_command']
  }
});

// Execute a task and await the structured result
const result = await agent.run('Please generate a bar chart for sales data');
console.log(result);

Deep dive into this pattern:

The ElcAgent class is the programmatic core of easy-llm-cli. Unlike the CLI which interactively prompts, this API enables embedded automation—CI pipelines, background jobs, custom IDE extensions.

The extension.mcpServers block is revolutionary. MCP (Model Context Protocol) servers are language-agnostic microservices that expose capabilities to the AI. The @antv/mcp-server-chart example connects AntV's visualization engine. When the agent receives "generate a bar chart," it doesn't hallucinate SVG—it calls the MCP server with structured data parameters, receives a rendered chart, and returns it.

The trust: false flag is critical security hygiene. Untrusted MCP servers can't execute without user confirmation. Meanwhile, excludeTools: ['run_shell_command'] creates capability sandboxing—even if the underlying model wants to run rm -rf /, this instance physically cannot.

Advanced pattern: Chain multiple agents with different tool permissions:

// Safe agent: read-only operations
const reader = new ElcAgent({ model: 'gpt-4.1', excludeTools: ['write_file'] });

// Privileged agent: destructive operations, human-in-the-loop
const writer = new ElcAgent({ model: 'claude-sonnet-4', trust: false });

// Orchestrate: reader analyzes, human approves, writer executes
const analysis = await reader.run('Analyze test failures');
// ... human review ...
await writer.run(`Fix these failures: ${analysis}`);

Advanced Usage & Best Practices

Provider Selection Strategy

Don't default to one model. Match capability to task using the test matrix:

Environment Isolation with direnv

Create .envrc files per project:

# ~/projects/client-a/.envrc
export USE_CUSTOM_LLM=true
export CUSTOM_LLM_MODEL_NAME="claude-sonnet-4"
export CUSTOM_LLM_API_KEY="sk-client-a-key"

# ~/projects/personal/.envrc
export USE_CUSTOM_LLM=true
export CUSTOM_LLM_ENDPOINT="http://localhost:8000/v1"
export CUSTOM_LLM_MODEL_NAME="qwen2.5-7b"

Switch contexts automatically by cd-ing between directories. No manual configuration, zero cross-project key leakage.

Token Optimization

All tested models support token counting. For massive codebases:

> Summarize the /src/api directory only, focusing on authentication patterns

Rather than:

> Explain this entire repository

Narrow context windows improve accuracy and reduce costs. Use .gitignore-style exclude patterns in extension config to omit node_modules, build artifacts, and generated code.

Comparison with Alternatives

The verdict: Copilot and Claude Code optimize for convenience within walled gardens. easy-llm-cli optimizes for freedom, transparency, and cost control. If you manage multiple projects with different AI requirements—or simply refuse to let a single vendor own your workflow—there's no contest.

FAQ: Developer Concerns Answered

Is easy-llm-cli officially affiliated with Google or Gemini?

No. It's a community fork that liberates Gemini CLI's architecture from Google's single-provider constraint. Think LibreOffice to OpenOffice, or MariaDB to MySQL^{↗ Bright Coding Blog}—same foundation, independent future.

Can I use my company's private LLM deployment?

Absolutely. Any OpenAI-compatible API works: Azure OpenAI, AWS^{↗ Bright Coding Blog} Bedrock (with adapter), self-hosted vLLM, TGI, or corporate proxies. Set CUSTOM_LLM_ENDPOINT to your internal URL.

How does MCP differ from simple shell commands?

MCP servers provide structured, typed interfaces with capability negotiation. A shell command pipes opaque text; an MCP server exposes schemas the LLM understands, enabling reliable multi-step workflows with error handling.

Is my code sent to third parties?

Only if you configure it to. Use local models via vLLM/Ollama for complete air-gapped operation. With cloud providers, code context follows that provider's terms—easy-llm-cli itself never intermediates or logs your data.

What about rate limits and costs?

You pay providers directly at their rates—no easy-llm-cli markup. Rotate between providers using the environment variable system when hitting limits. The test matrix helps you identify capable backups.

Can I contribute or customize?

Yes—it's fully open source. The repository includes CONTRIBUTING.md for development setup. Fork, modify MCP servers, add providers, or build IDE integrations via the programmatic API.

Does it work with monorepos?

Optimized for them. Large context windows (tested up to Gemini 2.5 Pro's capacity) ingest multi-package structures. Use targeted queries with path prefixes: > Analyze authentication in /packages/auth/src.

Conclusion: The Future Is Provider-Agnostic

The AI tooling landscape is fragmenting. New models launch weekly, each with strengths, weaknesses, and pricing experiments. Betting your entire workflow on one provider isn't strategy—it's technical debt.

easy-llm-cli solves this with elegant simplicity: one interface, every model, your choice. Forked from Google's foundation but evolved far beyond it, this tool embodies what developer tooling should be—open, adaptable, and ruthlessly practical.

The test matrix doesn't lie. Fifteen models validated across seven capability dimensions. Local deployment proven. Multimodal confirmed. MCP extensibility demonstrated. This isn't vaporware; it's production infrastructure that happens to fit in a terminal.

Stop managing five AI subscriptions. Stop copying code between browser tabs. Stop accepting vendor limitations as immutable law.

Install easy-llm-cli today. Configure your first custom provider in sixty seconds. Experience what it means when your terminal finally becomes as intelligent as the models you pay for.

npx easy-llm-cli

Your future self—the one effortlessly switching between Claude, DeepSeek, and local Qwen depending on the task—will thank you. The revolution is one command away.

⭐ Star the repository | 🐛 Report issues | 📖 Read full docs