Dependencies for Running FreeLLM API: A Complete Package Guide

TLDR: FreeLLM API requires separate Node.js dependencies for its four monorepo components—express, zod, and axios for the server; react, vite, and tailwindcss for the client; electron and electron-builder for the desktop wrapper; and typescript and lodash for the shared utilities—all defined in individual package.json files within each workspace.

FreeLLM API is a multi-package monorepo developed by tashfeenahmed/freellmapi that ships four distinct runnable components. Understanding the dependencies for running FreeLLM API is essential before deploying the HTTP gateway, web interface, or desktop application. Each component maintains its own dependency manifest in the repository root, enabling modular installation and targeted updates.

FreeLLM API Monorepo Architecture

The repository organizes code into four dedicated workspaces. Each workspace declares its own runtime and development dependencies, allowing you to install only what you need for your specific use case.

The four components are:

• Server: HTTP gateway handling authentication, request forwarding, and LLM provider integration
• Client: React-based web UI for testing and exploring API endpoints
• Desktop: Electron wrapper that packages the web UI as a native desktop application
• Shared: TypeScript types and utility functions used across all three runtimes

Server Dependencies

The server component, located in server/package.json, powers the HTTP API gateway that authenticates requests and forwards them to LLM providers. According to the tashfeenahmed/freellmapi source code, the server relies on express for the web framework, zod for schema validation, and axios for HTTP client operations.

Key runtime dependencies in server/package.json include:

• express – Web server framework
• dotenv – Environment variable management
• cors – Cross-origin resource sharing middleware
• zod – TypeScript-first schema validation
• @fastify/rate-limit and @fastify/helmet – Security and rate-limiting middleware
• axios – HTTP client for provider communication
• ts-node – TypeScript execution environment
• pino – Logging library
• node-cache – In-memory caching
• @vercel/kv – Vercel KV storage integration

The server entry point at server/src/index.ts initializes these dependencies, while server/src/services/router.ts implements the core request-routing logic including rate-limiting and provider selection.

Client Dependencies

The web UI client, defined in client/package.json, provides a React-based interface for testing the API. This component uses vite for the build tooling and tailwindcss for styling.

Key dependencies include:

• react and react-dom – UI library and DOM renderer
• vite and @vitejs/plugin-react – Build tooling and React plugin
• typescript – Type safety
• classnames – Conditional CSS class utilities
• axios – HTTP client for API calls
• zod – Runtime validation
• tailwindcss, postcss, and autoprefixer – CSS processing pipeline
• eslint and prettier – Code quality tools

The main React component resides in client/src/App.tsx, importing types from the shared workspace.

Desktop Dependencies

The desktop application, configured in desktop/package.json, wraps the client UI in an Electron shell. This component combines the client's React dependencies with Electron-specific tooling.

Key dependencies include:

• electron and electron-builder – Desktop application framework and packaging
• dotenv – Environment configuration
• node-fetch – HTTP client for the main process
• cross-env – Cross-platform environment variables
• concurrently – Running multiple commands simultaneously
• ts-node and typescript – TypeScript support
• react, react-dom, vite, and @vitejs/plugin-react – Shared with the client for UI rendering

The Electron main process is defined in desktop/src/main.ts, which creates the application window and loads the Vite-built UI.

Shared Dependencies

The shared/package.json contains utilities used across all three runtime components. This workspace minimizes code duplication by providing common types and helper functions.

Key dependencies include:

• zod – Shared schema definitions
• typescript – Type definitions
• lodash – Utility functions
• axios – Shared HTTP client configurations

The shared/types.ts file contains TypeScript type definitions imported by server/src/index.ts, client/src/App.tsx, and desktop/src/main.ts.

Installation and Setup Commands

To install the dependencies for running FreeLLM API, use the workspace-aware installation at the repository root. The monorepo structure allows you to install all dependencies across all four components simultaneously.

Install everything from the repository root:

npm install

This command installs dependencies for the shared workspace plus all three runnable components. After installation, start each component using the npm scripts defined in their respective package.json files.

Start the API server (exposes /v1/* endpoints):

npm run start:server

Launch the web UI development server:

npm run dev:client

Run the desktop Electron application:

npm run start:desktop

Key Source Files and Entry Points

Understanding the entry points helps troubleshoot dependency-related issues. The tashfeenahmed/freellmapi repository structures its source code with clear separation between components:

• server/src/index.ts – Entry point for the HTTP API server
• server/src/services/router.ts – Core request-routing logic including rate-limiting and provider selection
• client/src/App.tsx – Main React component for the web UI
• desktop/src/main.ts – Electron main process that creates the application window
• shared/types.ts – Shared TypeScript type definitions used across server, client, and desktop

These files import from their respective package.json dependencies, ensuring type safety and runtime functionality.

Summary

FreeLLM API distributes its dependencies across four distinct workspaces within a single monorepo. Key takeaways include:

• The server requires express, zod, and @fastify/rate-limit for API gateway functionality
• The client depends on react, vite, and tailwindcss for the web interface
• The desktop adds electron and electron-builder to the client stack
• The shared workspace provides typescript, zod, and lodash for cross-cutting concerns
• Each component maintains its own package.json in server/package.json, client/package.json, desktop/package.json, and shared/package.json

Frequently Asked Questions

Do I need to install all dependencies to run just the server?

No, you can install only the server dependencies if you only need the HTTP API gateway. Run npm install in the server/ directory after installing the shared/ workspace dependencies, or use the root installation and run only npm run start:server. The shared package must be built first since server/src/index.ts imports types from shared/types.ts.

What package manager does FreeLLM API use?

The repository supports both npm and pnpm based on the workspace configuration. The root package.json defines workspaces for the four components, allowing npm install at the root to install all dependencies across the monorepo. Individual components can also be installed separately using their respective package.json files.

Can I run the client without the desktop Electron wrapper?

Yes, the client is a standalone React application that runs independently in the browser. Use npm run dev:client to start the Vite development server on http://localhost:5173. The desktop version simply wraps this same client in an Electron shell for native application behavior, but the web UI functions identically in both contexts.

Where are the provider API keys configured?

Provider API keys are managed through dotenv environment variables. The server component uses dotenv (listed in server/package.json) to load configuration from environment files. The server/src/services/router.ts file accesses these variables when authenticating requests and forwarding them to LLM providers like OpenAI or Anthropic.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}