MCPJungle
Self-hosted MCP Gateway for AI agents
Stars: 852
MCPJungle is a self-hosted MCP Gateway for private AI agents, serving as a registry for Model Context Protocol Servers. Developers use it to manage servers and tools centrally, while clients discover and consume tools from a single 'Gateway' MCP Server. Suitable for developers using MCP Clients like Claude & Cursor, building production-grade AI Agents, and organizations managing client-server interactions. The tool allows quick start, installation, usage, server and client setup, connection to Claude and Cursor, enabling/disabling tools, managing tool groups, authentication, enterprise features like access control and OpenTelemetry metrics. Limitations include lack of long-running connections to servers and no support for OAuth flow. Contributions are welcome.
README:
Self-hosted MCP Gateway for your private AI agents
MCPJungle is an open source, self-hosted Gateway for all your Model Context Protocol Servers.
🧑💻 Developers use it to register & manage MCP servers and the tools they provide from a central place.
🤖 MCP Clients use it to discover and consume all these tools from a single "Gateway" MCP Server.
MCPJungle is the only MCP Server your AI agents need to connect to!
- Developers using MCP Clients like Claude & Cursor that need to access MCP servers for tool-calling
- Developers building production-grade AI Agents that need to access MCP servers with built-in security, privacy and Access Control.
- Organisations wanting to view & manage all MCP client-server interactions from a central place. Hosted in their own datacenter 🔒
- Quick Start guide
- Installation
- Usage
- Limitations
- Contributing
This quickstart guide will show you how to:
- Start the MCPJungle server locally using
docker compose - Register a simple MCP server in mcpjungle
- Connect your Claude to mcpjungle to access your MCP tools
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.yaml
docker compose up -dDownload the mcpjungle CLI on your local machine either using brew or directly from the Releases Page.
brew install mcpjungle/mcpjungle/mcpjungleThe CLI lets you manage everything in mcpjungle.
Next, lets add an MCP server to mcpjungle using the CLI. For this example, we'll use context7.
mcpjungle register --name context7 --url https://mcp.context7.com/mcpUse the following configuration for your Claude MCP servers config:
{
"mcpServers": {
"mcpjungle": {
"command": "npx",
"args": [
"mcp-remote",
"http://localhost:8080/mcp",
"--allow-http"
]
}
}
}Once mcpjungle is added as an MCP to your Claude, try asking it the following:
Use context7 to get the documentation for `/lodash/lodash`
Claude will then attempt to call the context7__get-library-docs tool via MCPJungle, which will return the documentation for the Lodash library.
Congratulations! 🎉
You have successfully registered a remote MCP server in MCPJungle and called one of its tools via Claude
You can now proceed to play around with the mcpjungle and explore the documentation & CLI for more details.
MCPJungle is shipped as a stand-alone binary.
You can either download it from the Releases Page or use Homebrew to install it:
brew install mcpjungle/mcpjungle/mcpjungleVerify your installation by running
mcpjungle version[!IMPORTANT] On MacOS, you will have to use homebrew because the compiled binary is not Notarized yet.
MCPJungle provides a Docker image which is useful for running the registry server (more about it later).
docker pull ghcr.io/mcpjungle/mcpjungleMCPJungle has a Client-Server architecture and the binary lets you run both the Server and the Client.
The MCPJungle server is responsible for managing all the MCP servers registered in it and providing a unified MCP gateway for AI Agents to discover and call tools provided by these registered servers.
The gateway itself runs over streamable http transport and is accessible at the /mcp endpoint.
For running the MCPJungle server locally, docker compose is the recommended way:
# docker-compose.yaml is optimized for individuals running mcpjungle on their local machines for personal use.
# mcpjungle will run in `development` mode by default.
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.yaml
docker compose up -d
# docker-compose.prod.yaml is optimized for orgs deploying mcpjungle on a remote server for multiple users.
# mcpjungle will run in `enterprise` mode by default, which enables enterprise features.
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.prod.yaml
docker compose -f docker-compose.prod.yaml up -d[!NOTE] The
enterprisemode used to be calledproductionmode. The mode has now been renamed for clarity. Everything else remains the same.
This will start the MCPJungle server along with a persistent Postgres database container.
You can quickly verify that the server is running:
curl http://localhost:8080/healthIf you plan on registering stdio-based MCP servers that rely on npx or uvx, use mcpjungle's stdio tagged docker image instead.
MCPJUNGLE_IMAGE_TAG=latest-stdio docker compose up -d[!NOTE] If you're using
docker-compose.yaml, this is already the default image tag. You only need to specify the stdio image tag if you're usingdocker-compose.prod.yaml.
This image is significantly larger. But it is very convenient and recommended for running locally when you rely on stdio-based MCP servers.
For example, if you only want to register remote mcp servers like context7 and deepwiki, you can use the standard (minimal) image.
But if you also want to use stdio-based servers like filesystem, time, github, etc., you should use the stdio-tagged image instead.
[!NOTE] If your stdio servers rely on tools other than
npxoruvx, you will have to create a custom docker image that includes those dependencies along with the mcpjungle binary.
Production Deployment
The default MCPJungle Docker image is very lightweight - it only contains a minimal base image and the mcpjungle binary.
It is therefore suitable and recommended for production deployments.
For the database, we recommend you deploy a separate Postgres DB cluster and supply its endpoint to mcpjungle (see Database section below).
You can see the definitions of the standard Docker image and the stdio Docker image.
You can also run the server directly on your host machine using the binary:
mcpjungle startThis starts the main registry server and MCP gateway, accessible on port 8080 by default.
It is important that the mcpjungle server shuts down gracefully to ensure proper cleanup.
The recommended way to stop the server process is to send a SIGTERM signal to it.
The mcpjungle server relies on a database and by default, creates a SQLite DB file mcpjungle.db in the current working directory.
This is okay when you're just testing things out locally.
For more serious deployments, mcpjungle also supports Postgresql. You can supply the DSN to connect to it:
# You can supply the database DSN as an env var
export DATABASE_URL=postgres://admin:root@localhost:5432/mcpjungle_db
#run as container
docker run ghcr.io/mcpjungle/mcpjungle:latest
# or run directly
mcpjungle startYou can also supply postgres-specific env vars or files if you don't prefer using the DSN:
# host is mandatory if you're using postgres-specific env vars
export POSTGRES_HOST=localhost
export POSTGRES_PORT=5432
export POSTGRES_USER=admin
export POSTGRES_USER_FILE=/path/to/user-file
export POSTGRES_PASSWORD=secret
export POSTGRES_PASSWORD_FILE=/path/to/password-file
export POSTGRES_DB=mcpjungle_db
export POSTGRES_DB_FILE=/path/to/db-file
mcpjungle startOnce the server is up, you can use the mcpjungle CLI to interact with it.
MCPJungle currently supports MCP servers using stdio and Streamable HTTP Transports.
[!NOTE] Support for SSE (server-sent events) also exists but is currently not mature.
Let's see how to register them in mcpjungle.
Let's say you're already running a streamable http MCP server locally at http://127.0.0.1:8000/mcp which provides basic math tools like add, subtract, etc.
You can register this MCP server with MCPJungle:
mcpjungle register --name calculator --description "Provides some basic math tools" --url http://127.0.0.1:8000/mcpIf you used docker compose to run the server, and you're not on Linux, you will have to use host.docker.internal instead of your local loopback address.
mcpjungle register --name calculator --description "Provides some basic math tools" --url http://host.docker.internal:8000/mcpThe registry will now start tracking this MCP server and load its tools.
You can also provide a configuration file to register the MCP server:
cat ./calculator.json
{
"name": "calculator",
"transport": "streamable_http",
"description": "Provides some basic math tools",
"url": "http://127.0.0.1:8000/mcp"
}
mcpjungle register -c ./calculator.jsonAll tools provided by this server are now accessible via MCPJungle:
mcpjungle list tools
# Check tool usage
mcpjungle usage calculator__multiply
# Call a tool
mcpjungle invoke calculator__multiply --input '{"a": 100, "b": 50}'[!NOTE] A tool in MCPJungle must be referred to by its canonical name which follows the pattern
<mcp-server-name>__<tool-name>. Server name and tool name are separated by a double underscore__.eg- If you register a MCP server
githubwhich provides a tool calledgit_commit, you can invoke it in MCPJungle using the namegithub__git_commit.Your MCP client must also use this canonical name to call the tool via MCPJungle.
The config file format for registering a Streamable HTTP-based MCP server is:
{
"name": "<name of your mcp server>",
"transport": "streamable_http",
"description": "<description>",
"url": "<url of the mcp server>",
"bearer_token": "<optional bearer token for authentication>",
"headers": {
"<custom http header>": "<value>"
}
}Here's an example configuration file (let's call it filesystem.json) for a MCP server that uses the STDIO transport:
{
"name": "filesystem",
"transport": "stdio",
"description": "filesystem mcp server",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
}You can register this MCP server in MCPJungle by providing the configuration file:
# Save the JSON configuration to a file (e.g., filesystem.json)
mcpjungle register -c ./filesystem.jsonThe config file format for registering a STDIO-based MCP server is:
{
"name": "<name of your mcp server>",
"transport": "stdio",
"description": "<description>",
"command": "<command to run the mcp server, eg- 'npx', 'uvx'>",
"args": ["arguments", "to", "pass", "to", "the", "command"],
"env": {
"KEY": "value"
}
}You can also watch a quick video on How to register a STDIO-based MCP server.
[!TIP] If your STDIO server fails or throws errors for some reason, check the mcpjungle server's logs to view its
stderroutput.
Caveat
When running mcpjungle inside Docker, you need some extra configuration to run the filesystem mcp server.
By default, mcpjungle inside container does not have access to your host filesystem.
So you must:
- mount the host directory you want to access as a volume in the container
- specify the mount path as the directory in the filesystem mcp server command args
The docker-compose.yaml provided by mcpjungle mounts the current working directory as /host in the container.
So you can use the following configuration for the filesystem mcp server:
{
"name": "filesystem",
"transport": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/host"]
}Then, the mcp has access to /host, ie, the current working directory on your host machine.
See DEVELOPMENT.md for more details.
You can remove a MCP server from mcpjungle.
mcpjungle deregister calculator
mcpjungle deregister filesystemOnce removed, this mcp server and its tools are no longer available to you or your MCP clients.
By default, MCPJungle always creates a new connection with the upstream MCP server when a tool is called.
When the tool call is complete, the connection is closed.
This keeps the system clean and avoids memory leaks.
But sometimes this can cause a latency overhead. For eg- a new process is spawned every time you call a tool of a STDIO-based mcp server. If the server takes several seconds to start up, this slows down the tool call and the overall interaction.
To solve this, MCPJungle also supports stateful connections.
You can set the session_mode to stateful (default is stateless) in you MCP server configuration:
{
"name": "filesystem",
"transport": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
"session_mode": "stateful"
}mcpjungle will create a new connection with this mcp server the first time you call one of its tools.
This connection is not closed when the tool call is complete. Subsequent tool calls to this server reuse the same connection, avoiding the cold-start overhead.
The connection is only closed when:
- mcpjungle server is stopped
- the mcp server is deregistered from mcpjungle
- the connection times out after a period of inactivity. You can set the number of seconds using the
SESSION_IDLE_TIMEOUT_SECenv var to configure this globally in mcpjungle server (default value is -1, which means no timeout).
When possible, it is recommended that you use stateless connections (default setting).
Assuming that MCPJungle is running on http://localhost:8080, use the following configurations to connect to it:
{
"mcpServers": {
"mcpjungle": {
"command": "npx",
"args": [
"mcp-remote",
"http://localhost:8080/mcp",
"--allow-http"
]
}
}
}{
"mcpServers": {
"mcpjungle": {
"url": "http://localhost:8080/mcp"
}
}
}You can watch a quick video on How to connect Cursor to MCPJungle.
Follow Copilot's doc on configuraing a MCP server manually.
Your mcp.json config file should look like this after adding mcpjungle to it:
{
"servers": {
"mcpjungle": {
"url": "http://localhost:8080/mcp"
}
}
}[!NOTE] You may have to click on
Startfor Copilot to actually start interacting with mcpjungle.
You can disable and re-enable a specific tool or all the tools provided by an MCP Server.
If a tool is disabled, it is not available via the MCPJungle Proxy or any of the Tool Groups, so no MCP clients can view or call it.
You can disable and enable Prompts as well.
# disable the `get-library-docs` tool provided by the `context7` MCP server
mcpjungle disable tool context7__get-library-docs
# re-enable the tool
mcpjungle enable tool context7__get-library-docs
# disable all tools in context7
mcpjungle disable tool context7
# disable the whole `context7` MCP server (disables all tools & prompts)
mcpjungle disable server context7
# re-enable `context7`
mcpjungle enable server context7
# disable a prompt
mcpjungle disable prompt "huggingface_Model Details"
# disable all prompts in context7
mcpjungle disable prompt context7A disabled tool is still accessible via mcpjungle's HTTP API, so humans can still manage it from the CLI (or any other HTTP client).
[!NOTE] When a new server is registered in MCPJungle, all its tools & prompts are enabled by default.
Mcpjungle supports Prompts.
When you register a new MCP server, if it provides prompts, they're registered in mcpjungle too.
Here are some examples of how you can interact with Prompts using the CLI:
# list all prompts provided by the huggingface mcp
$ mcpjungle list prompts --server huggingface
# Retrieve the "Model Details" prompt, supply custom arguments
$ mcpjungle get prompt "huggingface__Model Details" --arg model_id="openai/gpt-oss-120b"As you add more MCP servers to MCPJungle, the number of tools available through the Gateway can grow significantly.
If your MCP client is exposed to hundreds of tools through the gateway MCP, its performance may degrade.
MCPJungle allows you to expose only a subset of all available tools to your MCP clients using Tool Groups.
You can create a new group and only include specific tools that you wish to expose.
Once a group is created, mcpjungle returns a unique endpoint for it.
You can then configure your MCP client to use this group-specific endpoint instead of the main gateway endpoint.
You can create a new tool group by providing a JSON configuration file to the create group command.
You must specify a unique name for the group and define which tools to include using one or more of the following fields:
-
included_tools: List specific tool names to include (e.g.,["filesystem__read_file", "time__get_current_time"]) -
included_servers: Include ALL tools from specific MCP servers (e.g.,["time", "deepwiki"]) -
excluded_tools: Exclude specific tools (useful when including entire servers)
Here is an example of a tool group configuration file (claude-tools-group.json):
{
"name": "claude-tools",
"description": "This group only contains tools for Claude Desktop to use",
"included_tools": [
"filesystem__read_file",
"deepwiki__read_wiki_contents",
"time__get_current_time"
]
}This group exposes only 3 handpicked tools instead of all available tools.
You can also include all tools from specific servers and optionally exclude some:
{
"name": "claude-tools",
"description": "All tools from time and deepwiki servers except time__convert_time",
"included_servers": ["time", "deepwiki"],
"excluded_tools": ["time__convert_time"]
}This includes ALL tools from the time and deepwiki servers except time__convert_time.
You can combine all three fields for maximum flexibility:
{
"name": "comprehensive-tools",
"description": "Mix of manual tools, server inclusion, and exclusions",
"included_tools": ["filesystem__read_file"],
"included_servers": ["time"],
"excluded_tools": ["time__convert_time"]
}This includes filesystem__read_file plus all tools from the time server except time__convert_time.
You can create this group in mcpjungle:
$ mcpjungle create group -c ./claude-tools-group.json
Tool Group claude-tools created successfully
It is now accessible at the following streamable http endpoint:
http://127.0.0.1:8080/v0/groups/claude-tools/mcp
You can then configure Claude (or any other MCP client) to use this group-specific endpoint to access the MCP server.
The client will then ONLY see and be able to use these 3 tools and will not be aware of any other tools registered in MCPJungle.
[!TIP] You can run
mcpjungle list toolsto view all available tools and pick the ones you want to include in your group.
You can also watch a Video on using Tool Groups.
[!NOTE] The exclusion is always applied at the end. So if you add a tool to
included_toolsand also list it inexcluded_tools, it will be excluded from the final group.
Prompts are currently not supported in Tool Groups. We're working to fix this issue 🛠️
You can currently perform operations like listing all groups, viewing details of a specific group and deleting a group.
# list all tool groups
mcpjungle list groups
# view details of a specific group
mcpjungle get group claude-tools
# delete a group
mcpjungle delete group claude-toolsYou can list and invoke tools within specific groups using the --group flag:
# list tools in a specific group
mcpjungle list tools --group claude-tools
# invoke a tool from a specific group context
mcpjungle invoke filesystem__read_file --group claude-tools --input '{"path": "README.md"}'These commands provide group-scoped operations, making it easier to work with tools within specific contexts and validate that tools are available in your groups.
[!NOTE] If a tool is included in a group but is later disabled globally or deleted, then it will not be available via the group's MCP endpoint.
But if the tool is re-enabled or added again later, it will automatically become available in the group again.
Limitations 🚧
- Currently, you cannot update an existing tool group. You must delete the group and create a new one with the modified configuration file.
- In
enterprisemode, currently only an admin can create a Tool Group. We're working on allowing standard Users to create their own groups as well.
MCPJungle currently supports authentication if your Streamable HTTP MCP Server accepts static tokens for auth.
This is useful when using SaaS-provided MCP Servers like HuggingFace, Stripe, etc. which require your API token for authentication.
You can supply your token while registering the MCP server:
# If you specify the `--bearer-token` flag, MCPJungle will add the `Authorization: Bearer <token>` header to all requests made to this MCP server.
mcpjungle register --name huggingface --description "HuggingFace MCP Server" --url https://huggingface.co/mcp --bearer-token <your-hf-api-token>Or from your configuration file
{
"name": "huggingface",
"transport": "streamable_http",
"url": "https://huggingface.co/mcp",
"description": "hugging face mcp server",
"bearer_token": "<your-hf-api-token>"
}If you need to supply a custom value for the Authorization header or add additional custom headers, you can use the headers field in the config file:
{
"name": "sourcegraph",
"transport": "streamable_http",
"url": "https://sourcegraph.mycompany.com/.api/mcp",
"headers": {
"Authorization": "token <your-sourcegraph-token>",
"Custom-Header": "custom-value"
}
}Support for Oauth flow is coming soon!
If you're running MCPJungle in your organisation, we recommend running the Server in the enterprise mode:
# enable enterprise features by running in enterprise mode
mcpjungle start --enterprise
# you can also specify the server mode as environment variable (valid values are `development` and `enterprise`)
export SERVER_MODE=enterprise
mcpjungle start
# Or use the enterprise-mode docker compose file as described above
docker compose -f docker-compose.prod.yaml up -dBy default, mcpjungle server runs in development mode which is ideal for individuals running it locally.
In Enterprise mode, the server enforces stricter security policies and will provide additional features like Authentication, ACLs, observability and more.
After starting the server in enterprise mode, you must initialize it by running the following command on your client machine:
mcpjungle init-serverThis will create an admin user in the server and store its API access token in your home directory (~/.mcpjungle.conf).
You can then use the mcpjungle cli to make authenticated requests to the server.
In development mode, all MCP clients have full access to all the MCP servers registered in MCPJungle Proxy.
enterprise mode lets you control which MCP clients can access which MCP servers.
Suppose you have registered 2 MCP servers calculator and github in MCPJungle in enterprise mode.
By default, no MCP client can access these servers. You must create an MCP Client in mcpjungle and explicitly allow it to access the MCP servers.
# Create a new MCP client for your Cursor IDE to use. It can access the calculator and github MCP servers
mcpjungle create mcp-client cursor-local --allow "calculator, github"
MCP client 'cursor-local' created successfully!
Servers accessible: calculator,github
Access token: 1YHf2LwE1LXtp5lW_vM-gmdYHlPHdqwnILitBhXE4Aw
Send this token in the `Authorization: Bearer {token}` HTTP header.Mcpjungle creates an access token for your client.
Configure your client or agent to send this token in the Authorization header when making requests to the mcpjungle proxy.
[!TIP] You can also supply a custom access token for your mcp clients and user accounts using the
--access-tokenflag. This is useful when you want to manage tokens yourself, perhaps through a central identity server.
For example, you can add the following configuration in Cursor to connect to MCPJungle:
{
"mcpServers": {
"mcpjungle": {
"url": "http://localhost:8080/mcp",
"headers": {
"Authorization": "Bearer 1YHf2LwE1LXtp5lW_vM-gmdYHlPHdqwnILitBhXE4Aw"
}
}
}
}A client that has access to a particular server this way can view and call all the tools provided by that server.
[!NOTE] If you don't specify the
--allowflag, the MCP client will not be able to access any MCP servers.
You can also create an MCP client by providing a JSON configuration file:
{
"name": "foobar",
"allowed_servers": ["deepwiki", "time"],
"access_token": "my_secret_token_123",
"access_token_ref": {
"file": "/path/to/token-file.txt",
"env": "ENV_VAR_NAME"
}
}When creating a client from a config file, you must provide a custom access token because mcpjungle cannot print the generated token to the console.
There are 3 ways to provide the access token from configuration file:
- Directly in the
access_tokenfield: Only use this for testing purposes. Not recommended for production, especially if you're committing the config file to version control. - From a file using the
access_token_ref.filefield: The file should contain only the token string. - From an environment variable using the
access_token_ref.envfield: The env var should contain the token string.
In addition to MCP clients, you can also create User accounts in mcpjungle for human users.
A user has a very limited set of privileges compared to an admin in the enterprise mode. For example, they can view and use MCP servers, but they don't have write permissions in mcpjungle.
# Auto-generates a secret for user
mcpjungle create user bob
# Specify a custom access token for user
mcpjungle create user alice --access-token alice_token_123
# Create user from config file
mcpjungle create user --conf /path/to/user-config.jsonThe config file format for creating a user is similar to that of an MCP client:
{
"name": "charlie",
"access_token": "charlies_secret_token",
"access_token_ref": {
"file": "/path/to/token-file.txt",
"env": "ENV_VAR_NAME"
}
}Again, when using the config file, you must provide a custom access token.
MCPJungle supports Prometheus-compatible OpenTelemetry Metrics for observability.
- In
enterprisemode, OpenTelemetry is enabled by default. - In
developmentmode, telemetry is disabled by default. You can enable it by setting theOTEL_ENABLEDenvironment variable totruebefore starting the server:
# enable OpenTelemetry metrics
export OTEL_ENABLED=true
# optionally, set additional attributes to be added to all metrics
export OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=enterprise
# start the server
mcpjungle startOnce the mcpjungle server is started, metrics are available at the /metrics endpoint.
We're not perfect yet, but we're working hard to get there!
This is a work in progress.
We're collecting more feedback on how people use OAuth with MCP servers, so feel free to start a Discussion or open an issue to share your use case.
We welcome contributions from the community!
- For contribution guidelines and standards, see CONTRIBUTION.md
- For development setup and technical details, see DEVELOPMENT.md
Join our Discord community to connect with other contributors and maintainers.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for MCPJungle
Similar Open Source Tools
MCPJungle
MCPJungle is a self-hosted MCP Gateway for private AI agents, serving as a registry for Model Context Protocol Servers. Developers use it to manage servers and tools centrally, while clients discover and consume tools from a single 'Gateway' MCP Server. Suitable for developers using MCP Clients like Claude & Cursor, building production-grade AI Agents, and organizations managing client-server interactions. The tool allows quick start, installation, usage, server and client setup, connection to Claude and Cursor, enabling/disabling tools, managing tool groups, authentication, enterprise features like access control and OpenTelemetry metrics. Limitations include lack of long-running connections to servers and no support for OAuth flow. Contributions are welcome.
aiac
AIAC is a library and command line tool to generate Infrastructure as Code (IaC) templates, configurations, utilities, queries, and more via LLM providers such as OpenAI, Amazon Bedrock, and Ollama. Users can define multiple 'backends' targeting different LLM providers and environments using a simple configuration file. The tool allows users to ask a model to generate templates for different scenarios and composes an appropriate request to the selected provider, storing the resulting code to a file and/or printing it to standard output.
vector-inference
This repository provides an easy-to-use solution for running inference servers on Slurm-managed computing clusters using vLLM. All scripts in this repository run natively on the Vector Institute cluster environment. Users can deploy models as Slurm jobs, check server status and performance metrics, and shut down models. The repository also supports launching custom models with specific configurations. Additionally, users can send inference requests and set up an SSH tunnel to run inference from a local device.
slack-bot
The Slack Bot is a tool designed to enhance the workflow of development teams by integrating with Jenkins, GitHub, GitLab, and Jira. It allows for custom commands, macros, crons, and project-specific commands to be implemented easily. Users can interact with the bot through Slack messages, execute commands, and monitor job progress. The bot supports features like starting and monitoring Jenkins jobs, tracking pull requests, querying Jira information, creating buttons for interactions, generating images with DALL-E, playing quiz games, checking weather, defining custom commands, and more. Configuration is managed via YAML files, allowing users to set up credentials for external services, define custom commands, schedule cron jobs, and configure VCS systems like Bitbucket for automated branch lookup in Jenkins triggers.
magic-cli
Magic CLI is a command line utility that leverages Large Language Models (LLMs) to enhance command line efficiency. It is inspired by projects like Amazon Q and GitHub Copilot for CLI. The tool allows users to suggest commands, search across command history, and generate commands for specific tasks using local or remote LLM providers. Magic CLI also provides configuration options for LLM selection and response generation. The project is still in early development, so users should expect breaking changes and bugs.
vectorflow
VectorFlow is an open source, high throughput, fault tolerant vector embedding pipeline. It provides a simple API endpoint for ingesting large volumes of raw data, processing, and storing or returning the vectors quickly and reliably. The tool supports text-based files like TXT, PDF, HTML, and DOCX, and can be run locally with Kubernetes in production. VectorFlow offers functionalities like embedding documents, running chunking schemas, custom chunking, and integrating with vector databases like Pinecone, Qdrant, and Weaviate. It enforces a standardized schema for uploading data to a vector store and supports features like raw embeddings webhook, chunk validation webhook, S3 endpoint, and telemetry. The tool can be used with the Python client and provides detailed instructions for running and testing the functionalities.
loz
Loz is a command-line tool that integrates AI capabilities with Unix tools, enabling users to execute system commands and utilize Unix pipes. It supports multiple LLM services like OpenAI API, Microsoft Copilot, and Ollama. Users can run Linux commands based on natural language prompts, enhance Git commit formatting, and interact with the tool in safe mode. Loz can process input from other command-line tools through Unix pipes and automatically generate Git commit messages. It provides features like chat history access, configurable LLM settings, and contribution opportunities.
WindowsAgentArena
Windows Agent Arena (WAA) is a scalable Windows AI agent platform designed for testing and benchmarking multi-modal, desktop AI agents. It provides researchers and developers with a reproducible and realistic Windows OS environment for AI research, enabling testing of agentic AI workflows across various tasks. WAA supports deploying agents at scale using Azure ML cloud infrastructure, allowing parallel running of multiple agents and delivering quick benchmark results for hundreds of tasks in minutes.
smartcat
Smartcat is a CLI interface that brings language models into the Unix ecosystem, allowing power users to leverage the capabilities of LLMs in their daily workflows. It features a minimalist design, seamless integration with terminal and editor workflows, and customizable prompts for specific tasks. Smartcat currently supports OpenAI, Mistral AI, and Anthropic APIs, providing access to a range of language models. With its ability to manipulate file and text streams, integrate with editors, and offer configurable settings, Smartcat empowers users to automate tasks, enhance code quality, and explore creative possibilities.
hash
HASH is a self-building, open-source database which grows, structures and checks itself. With it, we're creating a platform for decision-making, which helps you integrate, understand and use data in a variety of different ways.
ray-llm
RayLLM (formerly known as Aviary) is an LLM serving solution that makes it easy to deploy and manage a variety of open source LLMs, built on Ray Serve. It provides an extensive suite of pre-configured open source LLMs, with defaults that work out of the box. RayLLM supports Transformer models hosted on Hugging Face Hub or present on local disk. It simplifies the deployment of multiple LLMs, the addition of new LLMs, and offers unique autoscaling support, including scale-to-zero. RayLLM fully supports multi-GPU & multi-node model deployments and offers high performance features like continuous batching, quantization and streaming. It provides a REST API that is similar to OpenAI's to make it easy to migrate and cross test them. RayLLM supports multiple LLM backends out of the box, including vLLM and TensorRT-LLM.
chat-ai
A Seamless Slurm-Native Solution for HPC-Based Services. This repository contains the stand-alone web interface of Chat AI, which can be set up independently to act as a wrapper for an OpenAI-compatible API endpoint. It consists of two Docker containers, 'front' and 'back', providing a ReactJS app served by ViteJS and a wrapper for message requests to prevent CORS errors. Configuration files allow setting port numbers, backend paths, models, user data, default conversation settings, and more. The 'back' service interacts with an OpenAI-compatible API endpoint using configurable attributes in 'back.json'. Customization options include creating a path for available models and setting the 'modelsPath' in 'front.json'. Acknowledgements to contributors and the Chat AI community are included.
vectara-answer
Vectara Answer is a sample app for Vectara-powered Summarized Semantic Search (or question-answering) with advanced configuration options. For examples of what you can build with Vectara Answer, check out Ask News, LegalAid, or any of the other demo applications.
claude-debugs-for-you
Claude Debugs For You is an MCP Server and VS Code extension that enables interactive debugging and evaluation of expressions with Claude or other LLM models. It is language-agnostic, requiring debugger console support and a valid launch.json for debugging in VSCode. Users can download the extension from releases or VS Code Marketplace, install it, and access commands through the status menu item 'Claude Debugs For You'. The tool supports debugging setups using stdio or /sse, and users can follow specific setup instructions depending on their configuration. Once set up, users can debug their code by interacting with the tool, which provides suggestions and fixes for identified issues.
laragenie
Laragenie is an AI chatbot designed to understand and assist developers with their codebases. It runs on the command line from a Laravel app, helping developers onboard to new projects, understand codebases, and provide daily support. Laragenie accelerates workflow and collaboration by indexing files and directories, allowing users to ask questions and receive AI-generated responses. It supports OpenAI and Pinecone for processing and indexing data, making it a versatile tool for any repo in any language.
safety-tooling
This repository, safety-tooling, is designed to be shared across various AI Safety projects. It provides an LLM API with a common interface for OpenAI, Anthropic, and Google models. The aim is to facilitate collaboration among AI Safety researchers, especially those with limited software engineering backgrounds, by offering a platform for contributing to a larger codebase. The repo can be used as a git submodule for easy collaboration and updates. It also supports pip installation for convenience. The repository includes features for installation, secrets management, linting, formatting, Redis configuration, testing, dependency management, inference, finetuning, API usage tracking, and various utilities for data processing and experimentation.
For similar tasks
MCPJungle
MCPJungle is a self-hosted MCP Gateway for private AI agents, serving as a registry for Model Context Protocol Servers. Developers use it to manage servers and tools centrally, while clients discover and consume tools from a single 'Gateway' MCP Server. Suitable for developers using MCP Clients like Claude & Cursor, building production-grade AI Agents, and organizations managing client-server interactions. The tool allows quick start, installation, usage, server and client setup, connection to Claude and Cursor, enabling/disabling tools, managing tool groups, authentication, enterprise features like access control and OpenTelemetry metrics. Limitations include lack of long-running connections to servers and no support for OAuth flow. Contributions are welcome.
octelium
Octelium is a free and open source, self-hosted, unified zero trust secure access platform that operates as a modern zero-config remote access VPN, a comprehensive Zero Trust Network Access (ZTNA)/BeyondCorp platform, an ngrok/Cloudflare Tunnel alternative, an API gateway, an AI/LLM gateway, a PaaS-like platform, a Kubernetes gateway/ingress, and a homelab infrastructure. It provides scalable zero trust architecture for identity-based, application-layer aware secure access via private client-based access over WireGuard/QUIC tunnels and public clientless access, with context-aware access control. Octelium offers dynamic secretless access, fine-grained access control, identity-based routing, continuous strong authentication, OpenTelemetry-native auditing, passwordless SSH, effortless deployment of containerized applications, centralized management, and more. It is open source, designed for self-hosting, and provides a commercial license option for businesses.
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.



