opencode-telegram-bot
OpenCode Telegram bot client for OpenCode CLI: run and monitor AI coding tasks from your phone while everything runs locally on your machine.
Stars: 85
OpenCode Telegram Bot is a secure Telegram client for OpenCode CLI that allows users to run AI coding tasks, monitor progress, switch models, and manage sessions from their phone. The bot communicates with the local OpenCode server and the Telegram Bot API only, ensuring security. It supports multiple languages and provides features like remote coding, session management, live status updates, model switching, agent modes, voice prompts, context control, input flow control, configurable reply formatting, strict user ID whitelist for security, and UI localization. Users can configure environment variables, voice and audio transcription, model settings, and more. The bot enforces security measures and supports various platforms like macOS, Windows, and Linux.
README:
OpenCode Telegram Bot is a secure Telegram client for OpenCode CLI that runs on your local machine.
Run AI coding tasks, monitor progress, switch models, and manage sessions from your phone.
No open ports, no exposed APIs. The bot communicates with your local OpenCode server and the Telegram Bot API only.
Languages: English (en), Deutsch (de), Español (es), Русский (ru), 简体中文 (zh)
Quick start: npx @grinev/opencode-telegram-bot
- Remote coding — send prompts to OpenCode from anywhere, receive complete results with code sent as files
- Session management — create new sessions or continue existing ones, just like in the TUI
- Live status — pinned message with current project, model, context usage, and changed files list, updated in real time
- Model switching — pick any model from your OpenCode favorites directly in the chat
- Agent modes — switch between Plan and Build modes on the fly
- Interactive Q&A — answer agent questions and approve permissions via inline buttons
- Voice prompts — send voice/audio messages, transcribe them via a Whisper-compatible API, then forward recognized text to OpenCode
- Context control — compact context when it gets too large, right from the chat
- Input flow control — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions
-
Configurable reply formatting — assistant replies use Telegram MarkdownV2 by default, with optional raw mode (
MESSAGE_FORMAT_MODE=markdown|raw) - Security — strict user ID whitelist; no one else can access your bot, even if they find it
-
Localization — UI localization is supported for multiple languages (
BOT_LOCALE)
- Node.js 20+ — download
- OpenCode — install from opencode.ai or GitHub
- Telegram Bot — you'll create one during setup (takes 1 minute)
- Open @BotFather in Telegram and send
/newbot - Follow the prompts to choose a name and username
- Copy the bot token you receive (e.g.
123456:ABC-DEF1234...)
You'll also need your Telegram User ID — send any message to @userinfobot and it will reply with your numeric ID.
Start the OpenCode server:
opencode serveThe bot connects to the OpenCode API at
http://localhost:4096by default.
The fastest way — run directly with npx:
npx @grinev/opencode-telegram-botOn first launch, an interactive wizard will guide you through the configuration — it asks for interface language first, then your bot token, user ID, and OpenCode API URL. After that, you're ready to go. Open your bot in Telegram and start sending tasks.
npm install -g @grinev/opencode-telegram-bot
opencode-telegram startTo reconfigure at any time:
opencode-telegram config| Platform | Status |
|---|---|
| macOS | Fully supported |
| Windows | Fully supported |
| Linux | Experimental — should work, but has not been extensively tested. You may need additional steps such as granting execute permissions. |
| Command | Description |
|---|---|
/status |
Server health, current project, session, and model info |
/new |
Create a new session |
/stop |
Abort the current task |
/sessions |
Browse and switch between recent sessions |
/projects |
Switch between OpenCode projects |
/rename |
Rename the current session |
/opencode_start |
Start the OpenCode server remotely |
/opencode_stop |
Stop the OpenCode server remotely |
/help |
Show available commands |
Any regular text message is sent as a prompt to the coding agent only when no blocking interaction is active. Voice/audio messages are transcribed and then sent as prompts when STT is configured.
/opencode_startand/opencode_stopare intended as emergency commands — for example, if you need to restart a stuck server while away from your computer. Under normal usage, startopencode serveyourself before launching the bot.
- Supported locales:
en,de,es,ru,zh - The setup wizard asks for language first
- You can change locale later with
BOT_LOCALE
When installed via npm, the configuration wizard handles the initial setup. The .env file is stored in your platform's app data directory:
-
macOS:
~/Library/Application Support/opencode-telegram-bot/.env -
Windows:
%APPDATA%\opencode-telegram-bot\.env -
Linux:
~/.config/opencode-telegram-bot/.env
| Variable | Description | Required | Default |
|---|---|---|---|
TELEGRAM_BOT_TOKEN |
Bot token from @BotFather | Yes | — |
TELEGRAM_ALLOWED_USER_ID |
Your numeric Telegram user ID | Yes | — |
TELEGRAM_PROXY_URL |
Proxy URL for Telegram API (SOCKS5/HTTP) | No | — |
OPENCODE_API_URL |
OpenCode server URL | No | http://localhost:4096 |
OPENCODE_SERVER_USERNAME |
Server auth username | No | opencode |
OPENCODE_SERVER_PASSWORD |
Server auth password | No | — |
OPENCODE_MODEL_PROVIDER |
Default model provider | Yes | opencode |
OPENCODE_MODEL_ID |
Default model ID | Yes | big-pickle |
BOT_LOCALE |
Bot UI language (supported locale code, e.g. en, de, es, ru, zh) |
No | en |
SESSIONS_LIST_LIMIT |
Max sessions shown in /sessions
|
No | 10 |
PROJECTS_LIST_LIMIT |
Max projects shown in /projects
|
No | 10 |
SERVICE_MESSAGES_INTERVAL_SEC |
Service messages interval (thinking + tool calls); keep >=2 to avoid Telegram rate limits, 0 = immediate |
No | 5 |
HIDE_THINKING_MESSAGES |
Hide 💭 Thinking... service messages |
No | false |
HIDE_TOOL_CALL_MESSAGES |
Hide tool-call service messages (💻 bash ..., 📖 read ..., etc.) |
No | false |
MESSAGE_FORMAT_MODE |
Assistant reply formatting mode: markdown (Telegram MarkdownV2) or raw
|
No | markdown |
CODE_FILE_MAX_SIZE_KB |
Max file size (KB) to send as document | No | 100 |
STT_API_URL |
Whisper-compatible API base URL (enables voice/audio transcription) | No | — |
STT_API_KEY |
API key for your STT provider | No | — |
STT_MODEL |
STT model name passed to /audio/transcriptions
|
No | whisper-large-v3-turbo |
STT_LANGUAGE |
Optional language hint (empty = provider auto-detect) | No | — |
LOG_LEVEL |
Log level (debug, info, warn, error) |
No | info |
Keep your
.envfile private. It contains your bot token. Never commit it to version control.
If STT_API_URL and STT_API_KEY are set, the bot will:
- Accept
voiceandaudioTelegram messages - Transcribe them via
POST {STT_API_URL}/audio/transcriptions - Show recognized text in chat
- Send the recognized text to OpenCode as a normal prompt
Supported provider examples (Whisper-compatible):
-
OpenAI
STT_API_URL=https://api.openai.com/v1STT_MODEL=whisper-1
-
Groq
STT_API_URL=https://api.groq.com/openai/v1STT_MODEL=whisper-large-v3-turbo
-
Together
STT_API_URL=https://api.together.xyz/v1STT_MODEL=openai/whisper-large-v3
If STT variables are not set, voice/audio transcription is disabled and the bot will ask you to configure STT.
The bot picks up your favorite models from OpenCode. To add a model to favorites:
- Open OpenCode TUI (
opencode) - Go to model selection
- Hover over the model you want and press Ctrl+F to add it to favorites
These favorites will appear in the model picker opened from the bottom Telegram keyboard.
A free model (opencode/big-pickle) is configured as the default fallback — if you haven't set up any favorites yet, the bot will use it automatically.
The bot enforces a strict user ID whitelist. Only the Telegram user whose numeric ID matches TELEGRAM_ALLOWED_USER_ID can interact with the bot. Messages from any other user are silently ignored and logged as unauthorized access attempts.
Since the bot runs locally on your machine and connects to your local OpenCode server, there is no external attack surface beyond the Telegram Bot API itself.
git clone https://github.com/grinev/opencode-telegram-bot.git
cd opencode-telegram-bot
npm install
cp .env.example .env
# Edit .env with your bot token, user ID, and model settingsBuild and run:
npm run dev| Script | Description |
|---|---|
npm run dev |
Build and start (development) |
npm run build |
Compile TypeScript |
npm start |
Run compiled code |
npm run release:notes:preview |
Preview auto-generated release notes |
npm run lint |
ESLint check (zero warnings policy) |
npm run format |
Format code with Prettier |
npm test |
Run tests (Vitest) |
npm run test:coverage |
Tests with coverage report |
Note: No file watcher or auto-restart is used. The bot maintains persistent SSE and long-polling connections — automatic restarts would break them mid-task. After making changes, restart manually with
npm run dev.
Bot doesn't respond to messages
- Make sure
TELEGRAM_ALLOWED_USER_IDmatches your actual Telegram user ID (check with @userinfobot) - Verify the bot token is correct
"OpenCode server is not available"
- Ensure
opencode serveis running in your project directory - Check that
OPENCODE_API_URLpoints to the correct address (default:http://localhost:4096)
No models in model picker
- Add models to your OpenCode favorites: open OpenCode TUI, go to model selection, press Ctrl+F on desired models
Linux: permission denied errors
- Make sure the CLI binary has execute permission:
chmod +x $(which opencode-telegram) - Check that the config directory is writable:
~/.config/opencode-telegram-bot/
Please follow commit and release note conventions in CONTRIBUTING.md.
MIT © Ruslan Grinev
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for opencode-telegram-bot
Similar Open Source Tools
opencode-telegram-bot
OpenCode Telegram Bot is a secure Telegram client for OpenCode CLI that allows users to run AI coding tasks, monitor progress, switch models, and manage sessions from their phone. The bot communicates with the local OpenCode server and the Telegram Bot API only, ensuring security. It supports multiple languages and provides features like remote coding, session management, live status updates, model switching, agent modes, voice prompts, context control, input flow control, configurable reply formatting, strict user ID whitelist for security, and UI localization. Users can configure environment variables, voice and audio transcription, model settings, and more. The bot enforces security measures and supports various platforms like macOS, Windows, and Linux.
localgpt
LocalGPT is a local device focused AI assistant built in Rust, providing persistent memory and autonomous tasks. It runs entirely on your machine, ensuring your memory data stays private. The tool offers a markdown-based knowledge store with full-text and semantic search capabilities, hybrid web search, and multiple interfaces including CLI, web UI, desktop GUI, and Telegram bot. It supports multiple LLM providers, is OpenClaw compatible, and offers defense-in-depth security features such as signed policy files, kernel-enforced sandbox, and prompt injection defenses. Users can configure web search providers, use OAuth subscription plans, and access the tool from Telegram for chat, tool use, and memory support.
pocketpaw
PocketPaw is a lightweight and user-friendly tool designed for managing and organizing your digital assets. It provides a simple interface for users to easily categorize, tag, and search for files across different platforms. With PocketPaw, you can efficiently organize your photos, documents, and other files in a centralized location, making it easier to access and share them. Whether you are a student looking to organize your study materials, a professional managing project files, or a casual user wanting to declutter your digital space, PocketPaw is the perfect solution for all your file management needs.
skyvern
Skyvern automates browser-based workflows using LLMs and computer vision. It provides a simple API endpoint to fully automate manual workflows, replacing brittle or unreliable automation solutions. Traditional approaches to browser automations required writing custom scripts for websites, often relying on DOM parsing and XPath-based interactions which would break whenever the website layouts changed. Instead of only relying on code-defined XPath interactions, Skyvern adds computer vision and LLMs to the mix to parse items in the viewport in real-time, create a plan for interaction and interact with them. This approach gives us a few advantages: 1. Skyvern can operate on websites it’s never seen before, as it’s able to map visual elements to actions necessary to complete a workflow, without any customized code 2. Skyvern is resistant to website layout changes, as there are no pre-determined XPaths or other selectors our system is looking for while trying to navigate 3. Skyvern leverages LLMs to reason through interactions to ensure we can cover complex situations. Examples include: 1. If you wanted to get an auto insurance quote from Geico, the answer to a common question “Were you eligible to drive at 18?” could be inferred from the driver receiving their license at age 16 2. If you were doing competitor analysis, it’s understanding that an Arnold Palmer 22 oz can at 7/11 is almost definitely the same product as a 23 oz can at Gopuff (even though the sizes are slightly different, which could be a rounding error!) Want to see examples of Skyvern in action? Jump to #real-world-examples-of- skyvern
foul-play
Foul Play is a Pokémon battle-bot that can play single battles in all generations on Pokemon Showdown. It requires Python 3.10+. The bot uses environment variables for configuration and supports different game modes and battle strategies. Users can specify teams and choose between algorithms like Monte-Carlo Tree Search and Expectiminimax. Foul Play can be run locally or with Docker, and the engine used for battles must be built from source. The tool provides flexibility in gameplay and strategy for Pokémon battles.
agent-deck
Agent Deck is a mission control tool for managing multiple AI coding agents in one terminal. It provides complete visibility of running, waiting, or idle agents, allows quick switching between sessions, and offers features like forking sessions, MCP manager for server attachment, skills manager for Claude skills, MCP socket pooling, search functionality, notification bar, git worktrees for multiple agents working on the same repo, and conductors for monitoring and orchestrating sessions. It supports various AI tools like Claude Code, Gemini CLI, OpenCode, Codex, Cursor, and custom tools. Agent Deck is designed to enhance AI session management beyond what tmux offers, with smart status detection, session forking, MCP management, global search, and organized groups.
wa_llm
WhatsApp Group Summary Bot is an AI-powered tool that joins WhatsApp groups, tracks conversations, and generates intelligent summaries. It features automated group chat responses, LLM-based conversation summaries, knowledge base integration, persistent message history with PostgreSQL, support for multiple message types, group management, and a REST API with Swagger docs. Prerequisites include Docker, Python 3.12+, PostgreSQL with pgvector extension, Voyage AI API key, and a WhatsApp account for the bot. The tool can be quickly set up by cloning the repository, configuring environment variables, starting services, and connecting devices. It offers API usage for loading new knowledge base topics and generating & dispatching summaries to managed groups. The project architecture includes FastAPI backend, WhatsApp Web API client, PostgreSQL database with vector storage, and AI-powered message processing.
iloom-cli
iloom is a tool designed to streamline AI-assisted development by focusing on maintaining alignment between human developers and AI agents. It treats context as a first-class concern, persisting AI reasoning in issue comments rather than temporary chats. The tool allows users to collaborate with AI agents in an isolated environment, switch between complex features without losing context, document AI decisions publicly, and capture key insights and lessons learned from AI sessions. iloom is not just a tool for managing git worktrees, but a control plane for maintaining alignment between users and their AI assistants.
lettabot
LettaBot is a personal AI assistant that operates across multiple messaging platforms including Telegram, Slack, Discord, WhatsApp, and Signal. It offers features like unified memory, persistent memory, local tool execution, voice message transcription, scheduling, and real-time message updates. Users can interact with LettaBot through various commands and setup wizards. The tool can be used for controlling smart home devices, managing background tasks, connecting to Letta Code, and executing specific operations like file exploration and internet queries. LettaBot ensures security through outbound connections only, restricted tool execution, and access control policies. Development and releases are automated, and troubleshooting guides are provided for common issues.
gollama
Gollama is a delightful tool that brings Ollama, your offline conversational AI companion, directly into your terminal. It provides a fun and interactive way to generate responses from various models without needing internet connectivity. Whether you're brainstorming ideas, exploring creative writing, or just looking for inspiration, Gollama is here to assist you. The tool offers an interactive interface, customizable prompts, multiple models selection, and visual feedback to enhance user experience. It can be installed via different methods like downloading the latest release, using Go, running with Docker, or building from source. Users can interact with Gollama through various options like specifying a custom base URL, prompt, model, and enabling raw output mode. The tool supports different modes like interactive, piped, CLI with image, and TUI with image. Gollama relies on third-party packages like bubbletea, glamour, huh, and lipgloss. The roadmap includes implementing piped mode, support for extracting codeblocks, copying responses/codeblocks to clipboard, GitHub Actions for automated releases, and downloading models directly from Ollama using the rest API. Contributions are welcome, and the project is licensed under the MIT License.
skilld
Skilld is a tool that generates AI agent skills from NPM dependencies, allowing users to enhance their agent's knowledge with the latest best practices and avoid deprecated patterns. It provides version-aware, local-first, and optimized skills for your codebase by extracting information from existing docs, changelogs, issues, and discussions. Skilld aims to bridge the gap between agent training data and the latest conventions, offering a semantic search feature, LLM-enhanced sections, and prompt injection sanitization. It operates locally without the need for external servers, providing a curated set of skills tied to your actual package versions.
k8s-operator
OpenClaw Kubernetes Operator is a platform for self-hosting AI agents on Kubernetes with production-grade security, observability, and lifecycle management. It allows users to run OpenClaw AI agents on their own infrastructure, managing inboxes, calendars, smart homes, and more through various integrations. The operator encodes network isolation, secret management, persistent storage, health monitoring, optional browser automation, and config rollouts into a single custom resource 'OpenClawInstance'. It manages a stack of Kubernetes resources ensuring security, monitoring, and self-healing. Features include declarative configuration, security hardening, built-in metrics, provider-agnostic config, config modes, skill installation, auto-update, backup/restore, workspace seeding, gateway auth, Tailscale integration, self-configuration, extensibility, cloud-native features, and more.
agenticSeek
AgenticSeek is a voice-enabled AI assistant powered by DeepSeek R1 agents, offering a fully local alternative to cloud-based AI services. It allows users to interact with their filesystem, code in multiple languages, and perform various tasks autonomously. The tool is equipped with memory to remember user preferences and past conversations, and it can divide tasks among multiple agents for efficient execution. AgenticSeek prioritizes privacy by running entirely on the user's hardware without sending data to the cloud.
RepairAgent
RepairAgent is an autonomous LLM-based agent for automated program repair targeting the Defects4J benchmark. It uses an LLM-driven loop to localize, analyze, and fix Java bugs. The tool requires Docker, VS Code with Dev Containers extension, OpenAI API key, disk space of ~40 GB, and internet access. Users can get started with RepairAgent using either VS Code Dev Container or Docker Image. Running RepairAgent involves checking out the buggy project version, autonomous bug analysis, fix candidate generation, and testing against the project's test suite. Users can configure hyperparameters for budget control, repetition handling, commands limit, and external fix strategy. The tool provides output structure, experiment overview, individual analysis scripts, and data on fixed bugs from the Defects4J dataset.
binary_ninja_mcp
This repository contains a Binary Ninja plugin, MCP server, and bridge that enables seamless integration of Binary Ninja's capabilities with your favorite LLM client. It provides real-time integration, AI assistance for reverse engineering, multi-binary support, and various MCP tools for tasks like decompiling functions, getting IL code, managing comments, renaming variables, and more.
TPI-LLM
TPI-LLM (Tensor Parallelism Inference for Large Language Models) is a system designed to bring LLM functions to low-resource edge devices, addressing privacy concerns by enabling LLM inference on edge devices with limited resources. It leverages multiple edge devices for inference through tensor parallelism and a sliding window memory scheduler to minimize memory usage. TPI-LLM demonstrates significant improvements in TTFT and token latency compared to other models, and plans to support infinitely large models with low token latency in the future.
For similar tasks
opencode-telegram-bot
OpenCode Telegram Bot is a secure Telegram client for OpenCode CLI that allows users to run AI coding tasks, monitor progress, switch models, and manage sessions from their phone. The bot communicates with the local OpenCode server and the Telegram Bot API only, ensuring security. It supports multiple languages and provides features like remote coding, session management, live status updates, model switching, agent modes, voice prompts, context control, input flow control, configurable reply formatting, strict user ID whitelist for security, and UI localization. Users can configure environment variables, voice and audio transcription, model settings, and more. The bot enforces security measures and supports various platforms like macOS, Windows, and Linux.
aiohttp-session
aiohttp_session is a Python library that provides session management for aiohttp.web applications. It allows storing user-specific data in session objects with a dict-like interface. The library offers different session storage options, including SimpleCookieStorage for testing, EncryptedCookieStorage for secure data storage, and RedisStorage for storing data in Redis. Users can easily integrate session management into their aiohttp.web applications by registering the session middleware. The library is designed to simplify session handling and enhance the security of web applications.
py-xiaozhi
py-xiaozhi is a Python-based XiaoZhi voice client designed for learning code and experiencing AI XiaoZhi's voice functions without hardware conditions. It features voice interaction, graphical interface, volume control, session management, encrypted audio transmission, CLI mode, and automatic copying of verification codes and opening browsers for first-time users. The project aims to optimize and add new features to zhh827's py-xiaozhi based on the original hardware project xiaozhi-esp32 and the Python implementation py-xiaozhi.
chatgpt-wechat
ChatGPT-WeChat is a personal assistant application that can be safely used on WeChat through enterprise WeChat without the risk of being banned. The project is open source and free, with no paid sections or external traffic operations except for advertising on the author's public account '积木成楼'. It supports various features such as secure usage on WeChat, multi-channel customer service message integration, proxy support, session management, rapid message response, voice and image messaging, drawing capabilities, private data storage, plugin support, and more. Users can also develop their own capabilities following the rules provided. The project is currently in development with stable versions available for use.
crush
Crush is a versatile tool designed to enhance coding workflows in your terminal. It offers support for multiple LLMs, allows for flexible switching between models, and enables session-based work management. Crush is extensible through MCPs and works across various operating systems. It can be installed using package managers like Homebrew and NPM, or downloaded directly. Crush supports various APIs like Anthropic, OpenAI, Groq, and Google Gemini, and allows for customization through environment variables. The tool can be configured locally or globally, and supports LSPs for additional context. Crush also provides options for ignoring files, allowing tools, and configuring local models. It respects `.gitignore` files and offers logging capabilities for troubleshooting and debugging.
SWE-ReX
SWE-ReX is a runtime interface for interacting with sandboxed shell environments, allowing AI agents to run any command on any environment. It enables agents to interact with running shell sessions, use interactive command line tools, and manage multiple shell sessions in parallel. SWE-ReX simplifies agent development and evaluation by abstracting infrastructure concerns, supporting fast parallel runs on various platforms, and disentangling agent logic from infrastructure.
sandbox-agent
Sandbox Agent is a server that runs inside sandboxes to control coding agents remotely over HTTP. It provides a universal API to interact with coding agents like Claude Code, Codex, OpenCode, and Amp, allowing users to manage sessions, handle permissions, and stream events. The tool solves the challenges of executing coding agents remotely, standardizes APIs for different agents, and persists session data for later replay and auditing. It offers features like streaming events, human-in-the-loop interactions, automatic agent installation, and runs inside any sandbox environment.
Lim-Code
LimCode is a powerful VS Code AI programming assistant that supports multiple AI models, intelligent tool invocation, and modular architecture. It features support for various AI channels, a smart tool system for code manipulation, MCP protocol support for external tool extension, intelligent context management, session management, and more. Users can install LimCode from the plugin store or via VSIX, or build it from the source code. The tool offers a rich set of features for AI programming and code manipulation within the VS Code environment.
For similar jobs
promptflow
**Prompt flow** is a suite of development tools designed to streamline the end-to-end development cycle of LLM-based AI applications, from ideation, prototyping, testing, evaluation to production deployment and monitoring. It makes prompt engineering much easier and enables you to build LLM apps with production quality.
deepeval
DeepEval is a simple-to-use, open-source LLM evaluation framework specialized for unit testing LLM outputs. It incorporates various metrics such as G-Eval, hallucination, answer relevancy, RAGAS, etc., and runs locally on your machine for evaluation. It provides a wide range of ready-to-use evaluation metrics, allows for creating custom metrics, integrates with any CI/CD environment, and enables benchmarking LLMs on popular benchmarks. DeepEval is designed for evaluating RAG and fine-tuning applications, helping users optimize hyperparameters, prevent prompt drifting, and transition from OpenAI to hosting their own Llama2 with confidence.
MegaDetector
MegaDetector is an AI model that identifies animals, people, and vehicles in camera trap images (which also makes it useful for eliminating blank images). This model is trained on several million images from a variety of ecosystems. MegaDetector is just one of many tools that aims to make conservation biologists more efficient with AI. If you want to learn about other ways to use AI to accelerate camera trap workflows, check out our of the field, affectionately titled "Everything I know about machine learning and camera traps".
leapfrogai
LeapfrogAI is a self-hosted AI platform designed to be deployed in air-gapped resource-constrained environments. It brings sophisticated AI solutions to these environments by hosting all the necessary components of an AI stack, including vector databases, model backends, API, and UI. LeapfrogAI's API closely matches that of OpenAI, allowing tools built for OpenAI/ChatGPT to function seamlessly with a LeapfrogAI backend. It provides several backends for various use cases, including llama-cpp-python, whisper, text-embeddings, and vllm. LeapfrogAI leverages Chainguard's apko to harden base python images, ensuring the latest supported Python versions are used by the other components of the stack. The LeapfrogAI SDK provides a standard set of protobuffs and python utilities for implementing backends and gRPC. LeapfrogAI offers UI options for common use-cases like chat, summarization, and transcription. It can be deployed and run locally via UDS and Kubernetes, built out using Zarf packages. LeapfrogAI is supported by a community of users and contributors, including Defense Unicorns, Beast Code, Chainguard, Exovera, Hypergiant, Pulze, SOSi, United States Navy, United States Air Force, and United States Space Force.
llava-docker
This Docker image for LLaVA (Large Language and Vision Assistant) provides a convenient way to run LLaVA locally or on RunPod. LLaVA is a powerful AI tool that combines natural language processing and computer vision capabilities. With this Docker image, you can easily access LLaVA's functionalities for various tasks, including image captioning, visual question answering, text summarization, and more. The image comes pre-installed with LLaVA v1.2.0, Torch 2.1.2, xformers 0.0.23.post1, and other necessary dependencies. You can customize the model used by setting the MODEL environment variable. The image also includes a Jupyter Lab environment for interactive development and exploration. Overall, this Docker image offers a comprehensive and user-friendly platform for leveraging LLaVA's capabilities.
carrot
The 'carrot' repository on GitHub provides a list of free and user-friendly ChatGPT mirror sites for easy access. The repository includes sponsored sites offering various GPT models and services. Users can find and share sites, report errors, and access stable and recommended sites for ChatGPT usage. The repository also includes a detailed list of ChatGPT sites, their features, and accessibility options, making it a valuable resource for ChatGPT users seeking free and unlimited GPT services.
TrustLLM
TrustLLM is a comprehensive study of trustworthiness in LLMs, including principles for different dimensions of trustworthiness, established benchmark, evaluation, and analysis of trustworthiness for mainstream LLMs, and discussion of open challenges and future directions. Specifically, we first propose a set of principles for trustworthy LLMs that span eight different dimensions. Based on these principles, we further establish a benchmark across six dimensions including truthfulness, safety, fairness, robustness, privacy, and machine ethics. We then present a study evaluating 16 mainstream LLMs in TrustLLM, consisting of over 30 datasets. The document explains how to use the trustllm python package to help you assess the performance of your LLM in trustworthiness more quickly. For more details about TrustLLM, please refer to project website.
AI-YinMei
AI-YinMei is an AI virtual anchor Vtuber development tool (N card version). It supports fastgpt knowledge base chat dialogue, a complete set of solutions for LLM large language models: [fastgpt] + [one-api] + [Xinference], supports docking bilibili live broadcast barrage reply and entering live broadcast welcome speech, supports Microsoft edge-tts speech synthesis, supports Bert-VITS2 speech synthesis, supports GPT-SoVITS speech synthesis, supports expression control Vtuber Studio, supports painting stable-diffusion-webui output OBS live broadcast room, supports painting picture pornography public-NSFW-y-distinguish, supports search and image search service duckduckgo (requires magic Internet access), supports image search service Baidu image search (no magic Internet access), supports AI reply chat box [html plug-in], supports AI singing Auto-Convert-Music, supports playlist [html plug-in], supports dancing function, supports expression video playback, supports head touching action, supports gift smashing action, supports singing automatic start dancing function, chat and singing automatic cycle swing action, supports multi scene switching, background music switching, day and night automatic switching scene, supports open singing and painting, let AI automatically judge the content.
