LLMs on Producthunt daily

skyvern

Fri, 07 Nov 2025 15:28:55 +0800

Skyvern-AI/skyvern

🐉 Automate Browser-based workflows using LLMs and Computer Vision 🐉

Skyvern automates browser-based workflows using LLMs and computer vision. It provides a simple API endpoint to fully automate manual workflows on a large number of websites, 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 relies on Vision LLMs to learn and interact with the websites.

How it works

Skyvern was inspired by the Task-Driven autonomous agent design popularized by BabyAGI and AutoGPT – with one major bonus: we give Skyvern the ability to interact with websites using browser automation libraries like Playwright.

Skyvern uses a swarm of agents to comprehend a website, and plan and execute its actions:

This approach has a few advantages:

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
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
Skyvern is able to take a single workflow and apply it to a large number of websites, as it’s able to reason through the interactions necessary to complete the workflow
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!)

A detailed technical report can be found here.

Demo

https://github.com/user-attachments/assets/5cab4668-e8e2-4982-8551-aab05ff73a7f

Performance & Evaluation

Skyvern has SOTA performance on the WebBench benchmark with a 64.4% accuracy. The technical report + evaluation can be found here

Performance on WRITE tasks (eg filling out forms, logging in, downloading files, etc)

Skyvern is the best performing agent on WRITE tasks (eg filling out forms, logging in, downloading files, etc), which is primarily used for RPA (Robotic Process Automation) adjacent tasks.

Quickstart

Skyvern Cloud

Skyvern Cloud is a managed cloud version of Skyvern that allows you to run Skyvern without worrying about the infrastructure. It allows you to run multiple Skyvern instances in parallel and comes bundled with anti-bot detection mechanisms, proxy network, and CAPTCHA solvers.

If you’d like to try it out, navigate to app.skyvern.com and create an account.

Install & Run

Dependencies needed:

Python 3.11.x, works with 3.12, not ready yet for 3.13
NodeJS & NPM

Additionally, for Windows:

Rust
VS Code with C++ dev tools and Windows SDK

1. Install Skyvern

`1`	`pip install skyvern`

2. Run Skyvern

This is most helpful for first time run (db setup, db migrations etc).

`1`	`skyvern quickstart`

3. Run task

UI (Recommended)

Start the Skyvern service and UI (when DB is up and running)

`1`	`skyvern run all`

Go to http://localhost:8080 and use the UI to run a task

Code

from skyvern import Skyvern

skyvern = Skyvern()
task = await skyvern.run_task(prompt="Find the top post on hackernews today")
print(task)

Skyvern starts running the task in a browser that pops up and closes it when the task is done. You will be able to view the task from http://localhost:8080/history

You can also run a task on different targets:

from skyvern import Skyvern

# Run on Skyvern Cloud
skyvern = Skyvern(api_key="SKYVERN API KEY")

# Local Skyvern service
skyvern = Skyvern(base_url="http://localhost:8000", api_key="LOCAL SKYVERN API KEY")

task = await skyvern.run_task(prompt="Find the top post on hackernews today")
print(task)

Advanced Usage

Control your own browser (Chrome)

⚠️ WARNING: Since Chrome 136, Chrome refuses any CDP connect to the browser using the default user_data_dir. In order to use your browser data, Skyvern copies your default user_data_dir to ./tmp/user_data_dir the first time connecting to your local browser. ⚠️

Just With Python Code

from skyvern import Skyvern

# The path to your Chrome browser. This example path is for Mac.
browser_path = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
skyvern = Skyvern(
    base_url="http://localhost:8000",
    api_key="YOUR_API_KEY",
    browser_path=browser_path,
)
task = await skyvern.run_task(
    prompt="Find the top post on hackernews today",
)

With Skyvern Service

Add two variables to your .env file:

1
2
3

# The path to your Chrome browser. This example path is for Mac.
CHROME_EXECUTABLE_PATH="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
BROWSER_TYPE=cdp-connect

Restart Skyvern service skyvern run all and run the task through UI or code

Run Skyvern with any remote browser

Grab the cdp connection url and pass it to Skyvern

from skyvern import Skyvern

skyvern = Skyvern(cdp_url="your cdp connection url")
task = await skyvern.run_task(
    prompt="Find the top post on hackernews today",
)

Get consistent output schema from your run

You can do this by adding the data_extraction_schema parameter:

from skyvern import Skyvern

skyvern = Skyvern()
task = await skyvern.run_task(
    prompt="Find the top post on hackernews today",
    data_extraction_schema={
        "type": "object",
        "properties": {
            "title": {
                "type": "string",
                "description": "The title of the top post"
            },
            "url": {
                "type": "string",
                "description": "The URL of the top post"
            },
            "points": {
                "type": "integer",
                "description": "Number of points the post has received"
            }
        }
    }
)

Helpful commands to debug issues

# Launch the Skyvern Server Separately*
skyvern run server

# Launch the Skyvern UI
skyvern run ui

# Check status of the Skyvern service
skyvern status

# Stop the Skyvern service
skyvern stop all

# Stop the Skyvern UI
skyvern stop ui

# Stop the Skyvern Server Separately
skyvern stop server

Docker Compose setup

Make sure you have Docker Desktop installed and running on your machine
Make sure you don’t have postgres running locally (Run docker ps to check)
Clone the repository and navigate to the root directory
Run skyvern init llm to generate a .env file. This will be copied into the Docker image.
Fill in the LLM provider key on the docker-compose.yml. If you want to run Skyvern on a remote server, make sure you set the correct server ip for the UI container in docker-compose.yml.
Run the following command via the commandline:
1

docker compose up -d
Navigate to http://localhost:8080 in your browser to start using the UI

Important: Only one Postgres container can run on port 5432 at a time. If you switch from the CLI-managed Postgres to Docker Compose, you must first remove the original container:
1
docker rm -f postgresql-container

If you encounter any database related errors while using Docker to run Skyvern, check which Postgres container is running with docker ps.

Skyvern Features

Skyvern Tasks

Tasks are the fundamental building block inside Skyvern. Each task is a single request to Skyvern, instructing it to navigate through a website and accomplish a specific goal.

Tasks require you to specify a url, prompt, and can optionally include a data schema (if you want the output to conform to a specific schema) and error codes (if you want Skyvern to stop running in specific situations).

Skyvern Workflows

Workflows are a way to chain multiple tasks together to form a cohesive unit of work.

For example, if you wanted to download all invoices newer than January 1st, you could create a workflow that first navigated to the invoices page, then filtered down to only show invoices newer than January 1st, extracted a list of all eligible invoices, and iterated through each invoice to download it.

Another example is if you wanted to automate purchasing products from an e-commerce store, you could create a workflow that first navigated to the desired product, then added it to a cart. Second, it would navigate to the cart and validate the cart state. Finally, it would go through the checkout process to purchase the items.

Supported workflow features include:

Browser Task
Browser Action
Data Extraction
Validation
For Loops
File parsing
Sending emails
Text Prompts
HTTP Request Block
Custom Code Block
Uploading files to block storage
(Coming soon) Conditionals

Livestreaming

Skyvern allows you to livestream the viewport of the browser to your local machine so that you can see exactly what Skyvern is doing on the web. This is useful for debugging and understanding how Skyvern is interacting with a website, and intervening when necessary

Form Filling

Skyvern is natively capable of filling out form inputs on websites. Passing in information via the navigation_goal will allow Skyvern to comprehend the information and fill out the form accordingly.

Data Extraction

Skyvern is also capable of extracting data from a website.

You can also specify a data_extraction_schema directly within the main prompt to tell Skyvern exactly what data you’d like to extract from the website, in jsonc format. Skyvern’s output will be structured in accordance to the supplied schema.

File Downloading

Skyvern is also capable of downloading files from a website. All downloaded files are automatically uploaded to block storage (if configured), and you can access them via the UI.

Authentication

Skyvern supports a number of different authentication methods to make it easier to automate tasks behind a login. If you’d like to try it out, please reach out to us via email or discord.

🔐 2FA Support (TOTP)

Skyvern supports a number of different 2FA methods to allow you to automate workflows that require 2FA.

Examples include:

QR-based 2FA (e.g. Google Authenticator, Authy)
Email based 2FA
SMS based 2FA

🔐 Learn more about 2FA support here.

Password Manager Integrations

Skyvern currently supports the following password manager integrations:

Bitwarden
1Password
LastPass

Model Context Protocol (MCP)

Skyvern supports the Model Context Protocol (MCP) to allow you to use any LLM that supports MCP.

See the MCP documentation here

Zapier / Make.com / N8N Integration

Skyvern supports Zapier, Make.com, and N8N to allow you to connect your Skyvern workflows to other apps.

🔐 Learn more about 2FA support here.

Real-world examples of Skyvern

We love to see how Skyvern is being used in the wild. Here are some examples of how Skyvern is being used to automate workflows in the real world. Please open PRs to add your own examples!

Invoice Downloading on many different websites

Book a demo to see it live

Automate the job application process

💡 See it in action

Automate materials procurement for a manufacturing company

💡 See it in action

Navigating to government websites to register accounts or fill out forms

💡 See it in action

Filling out random contact us forms

💡 See it in action

Retrieving insurance quotes from insurance providers in any language

💡 See it in action

Contributor Setup

Make sure to have uv installed.

Run this to create your virtual environment (.venv)
1

uv sync --group dev
Perform initial server configuration
1

uv run skyvern quickstart
Navigate to http://localhost:8080 in your browser to start using the UI The Skyvern CLI supports Windows, WSL, macOS, and Linux environments.

Documentation

More extensive documentation can be found on our 📕 docs page. Please let us know if something is unclear or missing by opening an issue or reaching out to us via email or discord.

Supported LLMs

Provider	Supported Models
OpenAI	gpt4-turbo, gpt-4o, gpt-4o-mini
Anthropic	Claude 3 (Haiku, Sonnet, Opus), Claude 3.5 (Sonnet)
Azure OpenAI	Any GPT models. Better performance with a multimodal llm (azure/gpt4-o)
AWS Bedrock	Anthropic Claude 3 (Haiku, Sonnet, Opus), Claude 3.5 (Sonnet)
Gemini	Gemini 2.5 Pro and flash, Gemini 2.0
Ollama	Run any locally hosted model via Ollama
OpenRouter	Access models through OpenRouter
OpenAI-compatible	Any custom API endpoint that follows OpenAI’s API format (via liteLLM)

Environment Variables

OpenAI

Variable	Description	Type	Sample Value
`ENABLE_OPENAI`	Register OpenAI models	Boolean	`true`, `false`
`OPENAI_API_KEY`	OpenAI API Key	String	`sk-1234567890`
`OPENAI_API_BASE`	OpenAI API Base, optional	String	`https://openai.api.base`
`OPENAI_ORGANIZATION`	OpenAI Organization ID, optional	String	`your-org-id`

Recommended LLM_KEY: OPENAI_GPT4O, OPENAI_GPT4O_MINI, OPENAI_GPT4_1, OPENAI_O4_MINI, OPENAI_O3

Anthropic

Variable	Description	Type	Sample Value
`ENABLE_ANTHROPIC`	Register Anthropic models	Boolean	`true`, `false`
`ANTHROPIC_API_KEY`	Anthropic API key	String	`sk-1234567890`

RecommendedLLM_KEY: ANTHROPIC_CLAUDE3.5_SONNET, ANTHROPIC_CLAUDE3.7_SONNET, ANTHROPIC_CLAUDE4_OPUS, ANTHROPIC_CLAUDE4_SONNET

Azure OpenAI

Variable	Description	Type	Sample Value
`ENABLE_AZURE`	Register Azure OpenAI models	Boolean	`true`, `false`
`AZURE_API_KEY`	Azure deployment API key	String	`sk-1234567890`
`AZURE_DEPLOYMENT`	Azure OpenAI Deployment Name	String	`skyvern-deployment`
`AZURE_API_BASE`	Azure deployment api base url	String	`https://skyvern-deployment.openai.azure.com/`
`AZURE_API_VERSION`	Azure API Version	String	`2024-02-01`

Recommended LLM_KEY: AZURE_OPENAI

AWS Bedrock

Variable	Description	Type	Sample Value
`ENABLE_BEDROCK`	Register AWS Bedrock models. To use AWS Bedrock, you need to make sure your AWS configurations are set up correctly first.	Boolean	`true`, `false`

Recommended LLM_KEY: BEDROCK_ANTHROPIC_CLAUDE3.7_SONNET_INFERENCE_PROFILE, BEDROCK_ANTHROPIC_CLAUDE4_OPUS_INFERENCE_PROFILE, BEDROCK_ANTHROPIC_CLAUDE4_SONNET_INFERENCE_PROFILE

Gemini

Variable	Description	Type	Sample Value
`ENABLE_GEMINI`	Register Gemini models	Boolean	`true`, `false`
`GEMINI_API_KEY`	Gemini API Key	String	`your_google_gemini_api_key`

Recommended LLM_KEY: GEMINI_2.5_PRO_PREVIEW, GEMINI_2.5_FLASH_PREVIEW

Ollama

Variable	Description	Type	Sample Value
`ENABLE_OLLAMA`	Register local models via Ollama	Boolean	`true`, `false`
`OLLAMA_SERVER_URL`	URL for your Ollama server	String	`http://host.docker.internal:11434`
`OLLAMA_MODEL`	Ollama model name to load	String	`qwen2.5:7b-instruct`

Recommended LLM_KEY: OLLAMA

Note: Ollama does not support vision yet.

OpenRouter

Variable	Description	Type	Sample Value
`ENABLE_OPENROUTER`	Register OpenRouter models	Boolean	`true`, `false`
`OPENROUTER_API_KEY`	OpenRouter API key	String	`sk-1234567890`
`OPENROUTER_MODEL`	OpenRouter model name	String	`mistralai/mistral-small-3.1-24b-instruct`
`OPENROUTER_API_BASE`	OpenRouter API base URL	String	`https://api.openrouter.ai/v1`

Recommended LLM_KEY: OPENROUTER

OpenAI-Compatible

Variable	Description	Type	Sample Value
`ENABLE_OPENAI_COMPATIBLE`	Register a custom OpenAI-compatible API endpoint	Boolean	`true`, `false`
`OPENAI_COMPATIBLE_MODEL_NAME`	Model name for OpenAI-compatible endpoint	String	`yi-34b`, `gpt-3.5-turbo`, `mistral-large`, etc.
`OPENAI_COMPATIBLE_API_KEY`	API key for OpenAI-compatible endpoint	String	`sk-1234567890`
`OPENAI_COMPATIBLE_API_BASE`	Base URL for OpenAI-compatible endpoint	String	`https://api.together.xyz/v1`, `http://localhost:8000/v1`, etc.
`OPENAI_COMPATIBLE_API_VERSION`	API version for OpenAI-compatible endpoint, optional	String	`2023-05-15`
`OPENAI_COMPATIBLE_MAX_TOKENS`	Maximum tokens for completion, optional	Integer	`4096`, `8192`, etc.
`OPENAI_COMPATIBLE_TEMPERATURE`	Temperature setting, optional	Float	`0.0`, `0.5`, `0.7`, etc.
`OPENAI_COMPATIBLE_SUPPORTS_VISION`	Whether model supports vision, optional	Boolean	`true`, `false`

Supported LLM Key: OPENAI_COMPATIBLE

General LLM Configuration

Variable	Description	Type	Sample Value
`LLM_KEY`	The name of the model you want to use	String	See supported LLM keys above
`SECONDARY_LLM_KEY`	The name of the model for mini agents skyvern runs with	String	See supported LLM keys above
`LLM_CONFIG_MAX_TOKENS`	Override the max tokens used by the LLM	Integer	`128000`

Feature Roadmap

This is our planned roadmap for the next few months. If you have any suggestions or would like to see a feature added, please don’t hesitate to reach out to us via email or discord.

Open Source - Open Source Skyvern’s core codebase
Workflow support - Allow support to chain multiple Skyvern calls together
Improved context - Improve Skyvern’s ability to understand content around interactable elements by introducing feeding relevant label context through the text prompt
Cost Savings - Improve Skyvern’s stability and reduce the cost of running Skyvern by optimizing the context tree passed into Skyvern
Self-serve UI - Deprecate the Streamlit UI in favour of a React-based UI component that allows users to kick off new jobs in Skyvern
Workflow UI Builder - Introduce a UI to allow users to build and analyze workflows visually
Chrome Viewport streaming - Introduce a way to live-stream the Chrome viewport to the user’s browser (as a part of the self-serve UI)
Past Runs UI - Deprecate the Streamlit UI in favour of a React-based UI that allows you to visualize past runs and their results
Auto workflow builder (“Observer”) mode - Allow Skyvern to auto-generate workflows as it’s navigating the web to make it easier to build new workflows
Prompt Caching - Introduce a caching layer to the LLM calls to dramatically reduce the cost of running Skyvern (memorize past actions and repeat them!)
Web Evaluation Dataset - Integrate Skyvern with public benchmark tests to track the quality of our models over time
Improved Debug mode - Allow Skyvern to plan its actions and get “approval” before running them, allowing you to debug what it’s doing and more easily iterate on the prompt
Chrome Extension - Allow users to interact with Skyvern through a Chrome extension (incl voice mode, saving tasks, etc.)
Skyvern Action Recorder - Allow Skyvern to watch a user complete a task and then automatically generate a workflow for it
Interactable Livestream - Allow users to interact with the livestream in real-time to intervene when necessary (such as manually submitting sensitive forms)
Integrate LLM Observability tools - Integrate LLM Observability tools to allow back-testing prompt changes with specific data sets + visualize the performance of Skyvern over time
Langchain Integration - Create langchain integration in langchain_community to use Skyvern as a “tool”.

Contributing

We welcome PRs and suggestions! Don’t hesitate to open a PR/issue or to reach out to us via email or discord. Please have a look at our contribution guide and “Help Wanted” issues to get started!

If you want to chat with the skyvern repository to get a high level overview of how it is structured, how to build off it, and how to resolve usage questions, check out Code Sage.

Telemetry

By Default, Skyvern collects basic usage statistics to help us understand how Skyvern is being used. If you would like to opt-out of telemetry, please set the SKYVERN_TELEMETRY environment variable to false.

License

Skyvern’s open source repository is supported via a managed cloud. All of the core logic powering Skyvern is available in this open source repository licensed under the AGPL-3.0 License, with the exception of anti-bot measures available in our managed cloud offering.

If you have any questions or concerns around licensing, please contact us and we would be happy to help.

Star History

langchainjs

Thu, 16 Oct 2025 15:28:47 +0800

langchain-ai/langchainjs

🦜️🔗 LangChain.js

⚡ Building applications with LLMs through composability ⚡

Looking for the Python version? Check out LangChain.

To help you ship LangChain apps to production faster, check out LangSmith. LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.

⚡️ Quick Install

You can use npm, pnpm, or yarn to install LangChain.js

npm install -S langchain or pnpm install langchain or yarn add langchain

🌐 Supported Environments

LangChain is written in TypeScript and can be used in:

Node.js (ESM and CommonJS) - 20.x, 22.x, 24.x
Cloudflare Workers
Vercel / Next.js (Browser, Serverless and Edge functions)
Supabase Edge Functions
Browser
Deno

🤔 What is LangChain?

LangChain is a framework for developing applications powered by language models. It enables applications that:

Are context-aware: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
Reason: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)

This framework consists of several parts.

Open-source libraries: Build your applications using LangChain’s open-source building blocks, components, and third-party integrations. Use LangGraph.js to build stateful agents with first-class streaming and human-in-the-loop support.
Productionization: Use LangSmith to inspect, monitor and evaluate your chains, so that you can continuously optimize and deploy with confidence.
Deployment: Turn your LangGraph applications into production-ready APIs and Assistants with LangGraph Cloud.

The LangChain libraries themselves are made up of several different packages.

@langchain/core: Base abstractions.
@langchain/community: Third party integrations.
langchain: Chains, agents, and retrieval strategies that make up an application’s cognitive architecture.
LangGraph.js: LangGraph powers production-grade agents, trusted by Linkedin, Uber, Klarna, GitLab, and many more. Build robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph. Integrates smoothly with LangChain, but can be used without it.

Integrations may also be split into their own compatible packages.

This library aims to assist in the development of those types of applications. Common examples of these applications include:

❓Question Answering over specific documents

Documentation
End-to-end Example: Doc-Chatbot

💬 Chatbots

Documentation
End-to-end Example: Chat-LangChain

🚀 How does LangChain help?

The main value props of the LangChain libraries are:

Components: composable tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
Off-the-shelf chains: built-in assemblages of components for accomplishing higher-level tasks

Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones.

Components fall into the following modules:

📃 Model I/O:

This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.

📚 Retrieval:

Data Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.

🤖 Agents:

Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete. LangChain provides a standard interface for agents, along with LangGraph.js for building custom agents.

📖 Additional Resources

Getting started: installation, setting up the environment, simple examples
Overview of the interfaces, modules and integrations
Full Documentation
Tutorial walkthroughs
Langhain Forum
API Reference

💁 Contributing

As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

For detailed information on how to contribute, see here.

Please report any security issues or concerns following our security guidelines.

🖇️ Relationship with Python LangChain

This is built to integrate as seamlessly as possible with the LangChain Python package. Specifically, this means all objects (prompts, LLMs, chains, etc) are designed in a way where they can be serialized and shared between languages.

Prompt-Engineering-Guide

Tue, 14 Oct 2025 15:30:06 +0800

dair-ai/Prompt-Engineering-Guide

Prompt Engineering Guide

Announcements / Updates

🎓 We now offer self-paced prompt engineering courses under our DAIR.AI Academy. Join Now!
🎓 New course on Prompt Engineering for LLMs announced! Enroll here!
💼 We now offer several services like corporate training, consulting, and talks.
🌐 We now support 13 languages! Welcoming more translations.
👩‍🎓 We crossed 3 million learners in January 2024!
🎉 We have launched a new web version of the guide here
🔥 We reached #1 on Hacker News on 21 Feb 2023
🎉 The First Prompt Engineering Lecture went live here

Join our Discord

Subscribe to our YouTube

Subscribe to our Newsletter

Guides

You can also find the most up-to-date guides on our new website https://www.promptingguide.ai/.

Lecture

We have published a 1 hour lecture that provides a comprehensive overview of prompting techniques, applications, and tools.

Running the guide locally

To run the guide locally, for example to check the correct implementation of a new translation, you will need to:

Install Node >=18.0.0
Install pnpm if not present in your system. Check here for detailed instructions.
Install the dependencies: pnpm i next react react-dom nextra nextra-theme-docs
Boot the guide with pnpm dev
Browse the guide at http://localhost:3000/

Appearances

Some places where we have been featured:

Wall Street Journal - ChatGPT Can Give Great Answers. But Only If You Know How to Ask the Right Question
Forbes - Mom, Dad, I Want To Be A Prompt Engineer
Markettechpost - Best Free Prompt Engineering Resources (2023)

If you are using the guide for your work or research, please cite us as follows:

@article{Saravia_Prompt_Engineering_Guide_2022,
author = {Saravia, Elvis},
journal = {https://github.com/dair-ai/Prompt-Engineering-Guide},
month = {12},
title = {{Prompt Engineering Guide}},
year = {2022}
}

License

MIT License

Feel free to open a PR if you think something is missing here. Always welcome feedback and suggestions. Just open an issue!

aisheets

Thu, 11 Sep 2025 15:31:31 +0800

huggingface/aisheets

🤗 Hugging Face AI Sheets

Build, enrich, and transform datasets using AI models with no code. Deploy locally or on the Hub with access to thousands of open models.

Introduction • Try it out

What’s AI Sheets?

Hugging Face AI Sheets is an open-source tool for building, enriching, and transforming datasets using AI models with no code. The tool can be deployed locally or on the Hub. It lets you use thousands of open models from the Hugging Face Hub via Inference Providers or local models, including gpt-oss from OpenAI!

Quick Start

Using the AI Sheets Space

Try it instantly at https://huggingface.co/spaces/aisheets/sheets

Using Docker

First, get your Hugging Face token from https://huggingface.co/settings/tokens

export HF_TOKEN=your_token_here
docker run -p 3000:3000 \
-e HF_TOKEN=HF_TOKEN \
aisheets/sheets

Open http://localhost:3000 in your browser.

Using pnpm

First, install pnpm if you haven’t already.

git clone https://github.com/huggingface/aisheets.git
cd sheets
export HF_TOKEN=your_token_here
pnpm install --frozen-lockfile
pnpm dev

Open http://localhost:5173 in your browser.

Building for production

To build the production application, run:

`1`	`pnpm build`

This will create a production build in the dist directory.

Then, you can launch the built-in Express server to serve the production build:

1
2

export HF_TOKEN=your_token_here
pnpm serve

Running data generation scripts using HF Jobs

If you want to generate a larger dataset, you can use the above-mentioned config and script, like this:

hf jobs uv run \
-s HF_TOKEN=$HF_TOKEN \
https://github.com/huggingface/aisheets/raw/refs/heads/main/scripts/extend_dataset/with_inference_client.py \ # script for running the pipeline
nvidia/Nemotron-Personas dvilasuero/nemotron-kimi-qa-distilled \
--config https://huggingface.co/datasets/dvilasuero/nemotron-personas-kimi-questions/raw/main/config.yml \ # config with prompts
--num-rows 100 # limit to 100 rows, leave empty for the full dataset

Alternatively, you can use a script that utilizes vllm inference instead of the inference client. This script helps you to save on inference costs, but it requires you to set up a vllm-compatible flavor when running the job:

hf jobs uv run --flavor l4x1 \
-s HF_TOKEN=$HF_TOKEN \
https://github.com/huggingface/aisheets/raw/refs/heads/main/scripts/extend_dataset/with_vllm.py \ # script for running the pipeline
nvidia/Nemotron-Personas dvilasuero/nemotron-kimi-qa-distilled \
--config https://huggingface.co/datasets/dvilasuero/nemotron-personas-kimi-questions/raw/main/config.yml \ # config with prompts
--num-rows 100 \ # limit to 100 rows, leave empty for the full dataset
--vllm-model deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

Running AI Sheets with custom (and local) LLMs

By default, AI Sheets is configured to use the Huggingface Inference Providers API to run inference on the latest open-source models. However, you can also run Sheets with own custom LLMs, such as those hosted on your own infrastructure or other cloud providers. The only requirement is that your LLMs must support the OpenAI API specification.

Steps

When running AI Sheets with custom LLMs, you need to set some environment variables to point the inference calls to your custom LLMs. Here are the steps:

Set the MODEL_ENDPOINT_URL environment variable: This variable should point to the base URL of your custom LLM’s API endpoint. For example, if you are using Ollama to run your LLM locally, you would set it like this:

`1`	`export MODEL_ENDPOINT_URL=http://localhost:11434`

Since Ollama starts a local server on port 11434 by default, this URL will point to your local Ollama instance.

Set the MODEL_ENDPOINT_NAME environment variable: This variable should specify the name of the model you want to use. For example, if you are using the llama3 model, you would set it like this:

`1`	`export MODEL_ENDPOINT_NAME=llama3`

This is a crucial step to conform to the OpenAI API specification. The model name is a required parameter in the OpenAI API, and it is used to identify which model to use for inference.

Run the AI Sheets app: After setting the environment variables, you can run the Sheets app as usual. The app will now use your custom LLM for inference instead of the default Huggingface Inference Providers API as the default behavior. Anyway, all the models provided by the Huggingface Inference Providers API will still be available when selecting a model in the column settings.

Note: The text-to-image generation feature cannot be customized yet. It will always utilize the Hugging Face Inference Providers API to generate images. Take this into account when running AI Sheets with custom LLMs.

Example of running AI Sheets with Ollama

To run AI Sheets with Ollama, you can follow these steps:

Start the Ollama server, and run the model of your choice

1
2

export OLLAMA_NOHISTORY=1
ollama serve

`1`	`ollama run llama3`

(Visit the Ollama FAQ page to know more about Ollama server configuration)

Set the environment variables:

1
2

export MODEL_ENDPOINT_URL=http://localhost:11434
export MODEL_ENDPOINT_NAME=llama3

Run the AI Sheets app:

`1`	`pnpm serve`

This will start the AI Sheets app and use the llama3 model running on your local Ollama instance for inference.

Advanced configuration

AI Sheets defines some environment variables that can be used to customize the behavior of the application. In the following sections, we will describe the available environment variables and their usage.

Authentication

OAUTH_CLIENT_ID: The Hugging Face OAuth client ID for the application. This is used to authenticate users via the Hugging Face OAuth. If this variable is defined, it will be used to authenticate users. (See how to setup the Hugging Face OAuth here).
HF_TOKEN: A Hugging Face token to use for authentication. If this variable is defined, it will be used for authenticated inference calls, instead of the OAuth token.
OAUTH_SCOPES: The scopes to request during the OAuth authentication. The default value is openid profile inference-api manage-repos. This variable is used to request the necessary permissions for the application to function correctly, and normally does not need to be changed.

Inference

DEFAULT_MODEL: The default model id to use when calling the inference API for text generation. The default value is meta-llama/Llama-3.3-70B-Instruct. This variable can be used to change the default model used for text generation and must be a valid model id from the Hugging Face Hub,
DEFAULT_MODEL_PROVIDER: The default model provider to use when calling the inference API for text generation. The default value is nebius. This variable can be used to change the default model provider used for text generation and must be a valid provider from the Hugging Face Inference Providers.
ORG_BILLING: The organization billing to use for inference calls. If this variable is defined, the inference calls will be billed to the specified organization. This is useful for organizations that want to manage their inference costs and usage. Remember that users must be part of the organization to use this feature, or an HF_TOKEN of a user that is part of the organization must be defined.
MODEL_ENDPOINT_URL: The URL of a custom inference endpoint to use for text generation. If this variable is defined, it will be used instead of the default Hugging Face Inference API. This is useful for using custom inference endpoints that are not hosted on the Hugging Face Hub, such as Ollama or LLM Studio. The URL must be a valid endpoint that supports the OpenAI API format.
MODEL_ENDPOINT_NAME: The model id to use when calling the custom inference endpoint defined by MODEL_ENDPOINT_URL. This variable is required if MODEL_ENDPOINT_URL is defined for custom inference endpoints that require a model id, such as Ollama or LLM Studio. The model id must correspond to the model deployed on the custom inference endpoint.
NUM_CONCURRENT_REQUESTS: The number of concurrent requests to allow when calling the inference API in the column cells generation process. The default value is 5, and the maximum value is 10. This is useful to control the number of concurrent requests made to the inference API and avoid hitting rate limits defined by the provider.

Miscellaneous

DATA_DIR: The directory where the application will store all its data. The default value is ./data. This variable can be used to change the data directory used by the application. The directory must be writable by the application.
SERPER_API_KEY: The API key to use for the Serper web search API. If this variable is defined, it will be used to authenticate web search requests. If this variable is not defined, web search will be disabled. The Serper API key can be obtained from the Serper website.
TELEMETRY_ENABLED: A boolean value that indicates whether telemetry is enabled or not. The default value is 1. This variable can be used to disable telemetry if desired. Telemetry is used to collect anonymous usage data to help improve the application.
EXAMPLES_PROMPT_MAX_CONTEXT_SIZE: The maximum context size (in characters) for the examples section in the prompt for text generation. The default value is 8192. If the examples section exceeds this size, it will be truncated. This variable can be used when the examples section is too large and needs to be reduced to fit within the context size limits of the model.
SOURCES_PROMPT_MAX_CONTEXT_SIZE: The maximum context size (in characters) for the sources section in the prompt for text generation. The default value is 61440. If the sources section exceeds this size, it will be truncated. This variable can be used when the sources section is too large and needs to be reduced to fit within the context size limits of the model.

Developer docs

Dev dependencies on your vscode

vitest runner

https://marketplace.visualstudio.com/items?itemName=rluvaton.vscode-vitest

biome

https://marketplace.visualstudio.com/items?itemName=biomejs.biome

Project Structure

This project is using Qwik with QwikCity. QwikCity is just an extra set of tools on top of Qwik to make it easier to build a full site, including directory-based routing, layouts, and more.

Inside your project, you’ll see the following directory structure:

├── public/
│   └── ...
└── src/
    ├── components/ --> Stateless components
    │   └── ...
    ├── features/ --> Components with business logic
    │   └── ...
    └── routes/
        └── ...

src/routes: Provides the directory-based routing, which can include a hierarchy of layout.tsx layout files, and an index.tsx file as the page. Additionally, index.ts files are endpoints. Please see the routing docs for more info.
src/components: Recommended directory for components.
public: Any static assets, like images, can be placed in the public directory. Please see the Vite public directory for more info.

Development

Run this on your root folder

`1`	`touch .env`

Add in your .env file the following variable:

`1`	`HF_TOKEN=your_hugging_face_token`

Development mode uses Vite’s development server. The dev command will server-side render (SSR) the output during development.

`1`	`pnpm dev`

Note: during dev mode, Vite may request a significant number of .js files. This does not represent a Qwik production build.

Preview

The preview command will create a production build of the client modules, a production build of src/entry.preview.tsx, and run a local server. The preview server is only for convenience to preview a production build locally and should not be used as a production server.

`1`	`pnpm preview`

Production

The production build will generate client and server modules by running both client and server build commands. The build command will use Typescript to run a type check on the source code.

`1`	`pnpm build`

Express Server

This app has a minimal Express server implementation. After running a full build, you can preview the build using the command:

`1`	`pnpm serve`

Then visit http://localhost:3000/

activepieces

Tue, 02 Sep 2025 15:28:57 +0800

activepieces/activepieces

An open source replacement for Zapier

Documentation 🌪️ Create a Piece 🖉 Deploy 🔥 Join Discord

🤯 Welcome to Activepieces

All-in-one AI automation designed to be extensible through a type-safe pieces framework written in TypeScript. When you contribute pieces to Activepieces they become automatically available as MCP servers that you can use with LLMs through Claude Desktop, Cursor or Windsurf!

🔥 Why Activepieces is Different:

💖 Loved by Everyone: Intuitive interface and great experience for both technical and non-technical users with a quick learning curve.
🌐 Open Ecosystem: All pieces are open source and available on npmjs.com, 60% of the pieces are contributed by the community.
🛠️ Largest open source MCP toolkit: All our pieces (280+) are available as MCP that you can use with LLMs on Claude Desktop, Cursor or Windsurf.
🛠️ Pieces are written in Typescript: Pieces are npm packages in TypeScript, offering full customization with the best developer experience, including hot reloading for local piece development on your machine. 😎
🤖 AI-First: Native AI pieces let you experiment with various providers, or create your own agents using our AI SDK, and there is Copilot to help you build flows inside the builder.
🏢 Enterprise-Ready: Developers set up the tools, and anyone in the organization can use the no-code builder. Full customization from branding to control.
🔒 Secure by Design: Self-hosted and network-gapped for maximum security and control over your data.
🧠 Human in the Loop: Delay execution for a period of time or require approval. These are just pieces built on top of the piece framework, and you can build many pieces like that. 🎨
💻 Human Input Interfaces: Built-in support for human input triggers like “Chat Interface” 💬 and “Form Interface” 📝

🛠️ Builder Features:

Loops
Branches
Auto Retries
HTTP
Code with NPM
ASK AI in Code Piece (Non technical user can clean data without knowing to code)
Flows are fully versioned.
Languages Translations
Customizable Templates
200+ Pieces, check https://www.activepieces.com/pieces

We release updates frequently. Check the product changelog for the latest features.

🔌 Create Your Own Piece

Activepieces supports integrations with Google Sheets, OpenAI, Discord, RSS, and over 200 other services. Check out the full list of supported integrations, which is constantly expanding thanks to our community’s contributions.

As an open ecosystem, all integration source code is accessible in our repository. These integrations are versioned and published directly to npmjs.com upon contribution.

You can easily create your own integration using our TypeScript framework. For detailed instructions, please refer to our Contributor’s Guide.

License

Activepieces’ Community Edition is released as open source under the MIT license and enterprise features are released under Commercial License

Read more about the feature comparison here https://www.activepieces.com/docs/about/editions

💭 Join Our Community

🌐 Contributions

We welcome contributions big or small and in different directions. The best way to do this is to check this document and we are always up to talk on our Discord Server.

📚 Translations

Not into coding but still interested in contributing? Come join our Discord and visit https://www.activepieces.com/docs/about/i18n for more information.

🦫 Contributors

_{ShahedAlMashni} 🔌	_{AbdulTheActivePiecer} 🚧	_{Khaled Mashaly} 🚧	_{Mohammed Abu Aboud} 🚧	_{Abdulrahman Zeineddin} 🔌	_{ahmad jaber} 🔌	_{ashrafsamhouri} 🔌
_{Mohammad Abu Musa} 📆	_{Mukewa Wekalao} 🔌	_{Osama Abdallah Essa Haikal} 🔌	_Arman 🛡️	_{Oskar Krämer} 📖	_{Thibaut Patel} 🤔 🔌	_{Applesaucesomer} 🤔
_crazyTweek 🤔	_{Muhammad Tabaza} 🔌	_{Shay Punter} 📖 🔌	_abaza738 🔌	_{Jona Boeddinghaus} 🔌	_fomojola 💻	_{Alexander Storozhevsky} 💻
_J0LGER 🛡️	_{Patrick Veverka} 🐛	_{Berk Sümbül} 📖	_{Willian Guedes} 🔌	_{Abdullah Ranginwala} 💻	_{Dennis Tychsen} 🔌	_MyWay 🔌
_{Bibhuti Bhusan Panda} 🔌	_{Tarun Samanta} 🐛	_{Herman Kudria} 🔌	_{[NULL] Dev} 🔌	_{Jan Bebendorf} 🔌	_Nilesh 🔌	_{Vraj Gohil} 🔌
_BastienMe 🔌	_{Stephen Foskett} 📖	_Nathan 📖	_{Marcin Natanek} 🔌	_{Mark van Bellen} 🔌	_{Olivier Guzzi} 🔌	_{Osama Zakarneh} 🔌
_phestvik 🤔	_{Rajdeep Pal} 📖	_{Camilo Usuga} 🔌	_{Kishan Parmar} 📖 🔌	_BBND 🔌	_{Haseeb Rehman} 🔌	_{Rita Gorokhod} 🔌
_{Fábio Ferreira} 🔌	_{Florin Buffet} 📖	_{Drew Lewis} 🔌	_{Benjamin André-Micolon} 🔌	_{Denis Gurskij} 🔌	_{Nefer Lopez} 📖	_{fardeenpanjwani-codeglo} 📖
_{Landon Moir} 🔌	_{Diego Nijboer} 🔌	_{Tân Một Nắng} 🔌	_{Gavin Foley} 📖	_{Dennis Trautwein} 🐛	_{Andrew Rosenblatt} 🐛	_rika 🔌
_{Cyril Selasi} 🔌	_{Franck Nijimbere} 🔌	_{Aleksandr Denisov} 🔌	_{Reuben Swartz} 📖	_joselupianez 🔌	_{Awais Manzoor} 🐛 💻	_Andrei 🐛
_derbbre 📖	_{Maor Rozenfeld} 💻	_{Michael Huynh} 📖	_{Filip Dunđer} 💻	_{Don Thorp} 📖	_{Joe Workman} 🔌	_{Aykut Akgün} 💻
_{Yann Petitjean} 🔌 🐛	_pfernandez98 🔌	_{Daniel O.} 🔌	_{Meng-Yuan Huang} 📖	_Leyla 🐛	_i-nithin 🔌	_la3rence 🔌
_{Dennis Rongo} 🐛 🔌	_{Kartik Mehta} 📖 💻	_{Zakher Masri} 📖 💻	_{AbdullahBitar} 🔌	_{Mario Meyer} 🔌	_{Karim Khaleel} 🔌	_CPonchet 🐛
_{Olivier Sambourg} 🔌	_Ahmad(Ed) 🔌	_leenmashni 🔌	_{M Abdul Rauf} 📖	_{Vincent Barrier} 🔌	_John 💻 🔌	_{Joost de Valk} 🔌
_MJ 🔌	_{ShravanShenoy} 💻	_{Jon Kristian} 📖	_cr0fters 🐛	_{Bibek Timsina} 🐛	_{Viktor Szépe} 💻	_{Rendy Tan} 📖 🔌
_{Islam Abdelfattah} 🐛	_{Yoonjae Choi} 💻	_{Javier HM} 🔌	_{Mohamed Hassan} 🐛	_{Christian Schab} 🔌	_{Pratik Kinage} 🔌	_{Abdelrahman Mostafa} 🔌
_{Hamza Zagha} 🐛	_{Lasse Schuirmann} 🔌	_{Cyril Duchon-Doris} 🔌	_Javiink 🔌	_{Harshit Harchani} 🔌	_MrAkber 📖	_{marek-slavicek} 🔌
_hugh-codes 🔌	_{Alex Lewis} 🐛	_{Yuanlin Lin} 📖	_{Ala Shiban} 📖	_hamsh 💻	_{Anne Mariel Catapang} 🔌	_{Carlo Gino Catapang} 🔌
_{Aditya Rathore} 🔌	_coderbob2 🔌	_{Ramy Gamal} 🔌	_{Alexandru-Dan Pop} 💻	_{Frank Micheal} 🔌	_{Emmanuel Ferdman} 📖	_{Sany A} 🔌
_{Niels Swimberghe} 🐛	_lostinbug 🔌	_gushkool 🔌	_{Omar Sayed} 🔌	_{rSnapkoOpenOps} 🐛	_ahronshor 🔌	_Cezar 🐛
_{Shawn Lim} 🔌	_{Shawn Lim} 🔌	_pavloDeshko 🐛	_abc 💻	_{manoj kumar d} 🔌	_Feli 🔌	_Miguel 🔌
_{Instasent DEV} 🔌	_{Matthieu Lombard} 🔌	_beyondlevi 🔌	_{Rafal Zawadzki} 🔌	_{Simon Courtois} 🔌	_{alegria-solutions} 🔌	_D-Rowe-FS 🔌
_张晟杰 🔌	_Ashot 🔌	_{Amr Abu Aza} 🔌	_{John Goodliff} 🔌	_{Diwash Dev} 🔌	_André 🔌	_{Lou \| Digital Marketing} 🔌
_{Maarten Coppens} 🔌	_{Mahmoud Hamed} 🔌	_{Theo Dammaretz} 🔌	_s31w4n 📖 💻 🔌	_{Abdul Rahman} 🔌	_{Kent Smith} 🔌	_{Arvind Ramesh} 💻
_{valentin-mourtialon} 🔌	_psgpsg16 🔌	_{Mariia Shyn} 🔌	_{Joshua Heslin} 🔌	_Ahmad 🔌	_{Daniel Poon} 💻	_{Kévin Yu} 🔌
_노영은 🔌	_reemayoush 🔌	_Brice 🛡️	_{Mg Wunna} 🔌	_{Harikrishnan U M} 🐛	_{perrine-pullicino-alan} 🔌	_{Tiger Kaovilai} 💻
_CarefulGuru 🔌	_{Ankit Kumar Sharma} 🔌	_{Naeem Hassan} 🔌	_{Tim Petricola} 💻	_Amaan 🔌	_{Marc Llopart} 🔌	_{David Anyatonwu} 🔌
_neo773 🔌	_{Daniel-Klippa} 💻	_{Krushna Kanta Rout} 🔌	_{Nimesh Solanki} 💻	_{Rimjhim Yadav} 🔌	_gs03 🔌	_{Kunal Darekar} 🔌
_Sanket6652 🔌	_Animesh 🔌	_{Derek Johnson} 🔌	_MamieFurax 🔌	_{Harsh Jadhav} 💻	_{Lucas Lima de Souza} 🔌	_{Benjamin Benouarka} 💻
_{Chris Wu} 💻	_{Prasanna R} 💻	_AdminCraftHD 💻	_{Tanakit Phentun} 💻	_{Sergey Bondar} 🔌	_{Yusuf Çırak} 🔌	_{Ezhil Shanmugham} 🔌
_Anderson 🔌	_{Daniel Callado} 🔌	_{Ukaegbu Osinachi} 🔌	_{Rishi Mondal} 🔌	_Cloudieunnie 💻	_{Balwant Singh} 🔌	_{Ravi Kiran Vallamkonda} 💻
_{Owuzo Joy} 🔌	_{helenedurand-smet} 💻	_Nuvex 🔌	_{Apostol Eusebiu} 🔌	_Fortunate 🔌	_{Jaachịmmá Anyatọnwụ} 🔌	_{Luiz D. M. Mainart} 🔌

This project follows the all-contributors specification. Contributions of any kind are welcome!

Hands-On-Large-Language-Models

Wed, 27 Aug 2025 15:29:45 +0800

HandsOnLLM/Hands-On-Large-Language-Models

# Hands-On Large Language Models

Welcome! In this repository you will find the code for all examples throughout the book Hands-On Large Language Models written by Jay Alammar and Maarten Grootendorst which we playfully dubbed:

"The Illustrated LLM Book"

Through the visually educational nature of this book and with almost 300 custom made figures, learn the practical tools and concepts you need to use Large Language Models today!

The book is available on:

We advise to run all examples through Google Colab for the easiest setup. Google Colab allows you to use a T4 GPU with 16GB of VRAM for free. All examples were mainly built and tested using Google Colab, so it should be the most stable platform. However, any other cloud provider should work.

Chapter	Notebook
Chapter 1: Introduction to Language Models
Chapter 2: Tokens and Embeddings
Chapter 3: Looking Inside Transformer LLMs
Chapter 4: Text Classification
Chapter 5: Text Clustering and Topic Modeling
Chapter 6: Prompt Engineering
Chapter 7: Advanced Text Generation Techniques and Tools
Chapter 8: Semantic Search and Retrieval-Augmented Generation
Chapter 9: Multimodal Large Language Models
Chapter 10: Creating Text Embedding Models
Chapter 11: Fine-tuning Representation Models for Classification
Chapter 12: Fine-tuning Generation Models

[!TIP] You can check the setup folder for a quick-start guide to install all packages locally and you can check the conda folder for a complete guide on how to setup your environment, including conda and PyTorch installation. Note that the depending on your OS, Python version, and dependencies your results might be slightly differ. However, they should this be similar to the examples in the book.

Reviews

“Jay and Maarten have continued their tradition of providing beautifully illustrated and insightful descriptions of complex topics in their new book. Bolstered with working code, timelines, and references to key papers, their book is a valuable resource for anyone looking to understand the main techniques behind how Large Language Models are built.”

Andrew Ng - founder of DeepLearning.AI

“This is an exceptional guide to the world of language models and their practical applications in industry. Its highly-visual coverage of generative, representational, and retrieval applications of language models empowers readers to quickly understand, use, and refine LLMs. Highly recommended!”

Nils Reimers - Director of Machine Learning at Cohere | creator of sentence-transformers

“I can’t think of another book that is more important to read right now. On every single page, I learned something that is critical to success in this era of language models.”

Josh Starmer - StatQuest

“If you’re looking to get up to speed in everything regarding LLMs, look no further! In this wonderful book, Jay and Maarten will take you from zero to expert in the history and latest advances in large language models. With very intuitive explanations, great real-life examples, clear illustrations, and comprehensive code labs, this book lifts the curtain on the complexities of transformer models, tokenizers, semantic search, RAG, and many other cutting-edge technologies. A must read for anyone interested in the latest AI technology!”

Luis Serrano, PhD - Founder and CEO of Serrano Academy

“Hands-On Large Language Models brings clarity and practical examples to cut through the hype of AI. It provides a wealth of great diagrams and visual aids to supplement the clear explanations. The worked examples and code make concrete what other books leave abstract. The book starts with simple introductory beginnings, and steadily builds in scope. By the final chapters, you will be fine-tuning and building your own large language models with confidence.”

Leland McInnes - Researcher at the Tutte Institute for Mathematics and Computing | creator of UMAP and HDBSCAN

Bonus content!

We attempted to put as much information into the book without it being overwhelming. However, even with a 400-page book there is still much to discover!

We continue to create more guides that compliment the book and go more in-depth into new and exciting topics:

A Visual Guide to Mamba	A Visual Guide to Quantization	The Illustrated Stable Diffusion

A Visual Guide to Mixture of Experts	A Visual Guide to Reasoning LLMs	The Illustrated DeepSeek-R1

Citation

Please consider citing the book if you consider it useful for your research:

@book{hands-on-llms-book,
  author       = {Jay Alammar and Maarten Grootendorst},
  title        = {Hands-On Large Language Models},
  publisher    = {O'Reilly},
  year         = {2024},
  isbn         = {978-1098150969},
  url          = {https://www.oreilly.com/library/view/hands-on-large-language/9781098150952/},
  github       = {https://github.com/HandsOnLLM/Hands-On-Large-Language-Models}
}

gpt4all

Thu, 14 Aug 2025 15:31:32 +0800

nomic-ai/gpt4all

GPT4All

Now with support for DeepSeek R1 Distillations

Website • Documentation • Discord • YouTube Tutorial

GPT4All runs large language models (LLMs) privately on everyday desktops & laptops.

No API calls or GPUs required - you can just download the application and get started.

Read about what's new in our blog.

Subscribe to the newsletter

https://github.com/nomic-ai/gpt4all/assets/70534565/513a0f15-4964-4109-89e4-4f9a9011f311

GPT4All is made possible by our compute partner Paperspace.

Download Links

— Windows Installer —

— Windows ARM Installer —

— macOS Installer —

— Ubuntu Installer —

The Windows and Linux builds require Intel Core i3 2nd Gen / AMD Bulldozer, or better.

The Windows ARM build supports Qualcomm Snapdragon and Microsoft SQ1/SQ2 processors.

The Linux build is x86-64 only (no ARM).

The macOS build requires Monterey 12.6 or newer. Best results with Apple Silicon M-series processors.

See the full System Requirements for more details.

Flathub (community maintained)

Install GPT4All Python

gpt4all gives you access to LLMs with our Python client around llama.cpp implementations.

Nomic contributes to open source software like llama.cpp to make LLMs accessible and efficient for all.

`1`	`pip install gpt4all`

from gpt4all import GPT4All
model = GPT4All("Meta-Llama-3-8B-Instruct.Q4_0.gguf") # downloads / loads a 4.66GB LLM
with model.chat_session():
    print(model.generate("How can I run LLMs efficiently on my laptop?", max_tokens=1024))

Integrations

:parrot::link: Langchain :card_file_box: Weaviate Vector Database - module docs :telescope: OpenLIT (OTel-native Monitoring) - Docs

Release History

July 2nd, 2024: V3.0.0 Release
- Fresh redesign of the chat application UI
- Improved user workflow for LocalDocs
- Expanded access to more model architectures
October 19th, 2023: GGUF Support Launches with Support for:
- Mistral 7b base model, an updated model gallery on our website, several new local code models including Rift Coder v1.5
- Nomic Vulkan support for Q4_0 and Q4_1 quantizations in GGUF.
- Offline build support for running old versions of the GPT4All Local LLM Chat Client.
September 18th, 2023: Nomic Vulkan launches supporting local LLM inference on NVIDIA and AMD GPUs.
July 2023: Stable support for LocalDocs, a feature that allows you to privately and locally chat with your data.
June 28th, 2023: Docker-based API server launches allowing inference of local LLMs from an OpenAI-compatible HTTP endpoint.

Contributing

GPT4All welcomes contributions, involvement, and discussion from the open source community! Please see CONTRIBUTING.md and follow the issues, bug reports, and PR markdown templates.

Check project discord, with project owners, or through existing issues/PRs to avoid duplicate work. Please make sure to tag all of the above with relevant project identifiers or your contribution could potentially get lost. Example tags: backend, bindings, python-bindings, documentation, etc.

Citation

If you utilize this repository, models or data in a downstream project, please consider citing it with:

@misc{gpt4all,
  author = {Yuvanesh Anand and Zach Nussbaum and Brandon Duderstadt and Benjamin Schmidt and Andriy Mulyar},
  title = {GPT4All: Training an Assistant-style Chatbot with Large Scale Data Distillation from GPT-3.5-Turbo},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/nomic-ai/gpt4all}},
}

ollama

Fri, 08 Aug 2025 15:39:28 +0800

ollama/ollama

Ollama

Get up and running with large language models.

macOS

Download

Windows

Download

Linux

`1`	`curl -fsSL https://ollama.com/install.sh \| sh`

Manual install instructions

Docker

The official Ollama Docker image ollama/ollama is available on Docker Hub.

Libraries

Community

Quickstart

To run and chat with Gemma 3:

`1`	`ollama run gemma3`

Model library

Ollama supports a list of models available on ollama.com/library

Here are some example models that can be downloaded:

Model	Parameters	Size	Download
Gemma 3	1B	815MB	`ollama run gemma3:1b`
Gemma 3	4B	3.3GB	`ollama run gemma3`
Gemma 3	12B	8.1GB	`ollama run gemma3:12b`
Gemma 3	27B	17GB	`ollama run gemma3:27b`
QwQ	32B	20GB	`ollama run qwq`
DeepSeek-R1	7B	4.7GB	`ollama run deepseek-r1`
DeepSeek-R1	671B	404GB	`ollama run deepseek-r1:671b`
Llama 4	109B	67GB	`ollama run llama4:scout`
Llama 4	400B	245GB	`ollama run llama4:maverick`
Llama 3.3	70B	43GB	`ollama run llama3.3`
Llama 3.2	3B	2.0GB	`ollama run llama3.2`
Llama 3.2	1B	1.3GB	`ollama run llama3.2:1b`
Llama 3.2 Vision	11B	7.9GB	`ollama run llama3.2-vision`
Llama 3.2 Vision	90B	55GB	`ollama run llama3.2-vision:90b`
Llama 3.1	8B	4.7GB	`ollama run llama3.1`
Llama 3.1	405B	231GB	`ollama run llama3.1:405b`
Phi 4	14B	9.1GB	`ollama run phi4`
Phi 4 Mini	3.8B	2.5GB	`ollama run phi4-mini`
Mistral	7B	4.1GB	`ollama run mistral`
Moondream 2	1.4B	829MB	`ollama run moondream`
Neural Chat	7B	4.1GB	`ollama run neural-chat`
Starling	7B	4.1GB	`ollama run starling-lm`
Code Llama	7B	3.8GB	`ollama run codellama`
Llama 2 Uncensored	7B	3.8GB	`ollama run llama2-uncensored`
LLaVA	7B	4.5GB	`ollama run llava`
Granite-3.3	8B	4.9GB	`ollama run granite3.3`

[!NOTE] You should have at least 8 GB of RAM available to run the 7B models, 16 GB to run the 13B models, and 32 GB to run the 33B models.

Customize a model

Import from GGUF

Ollama supports importing GGUF models in the Modelfile:

Create a file named Modelfile, with a FROM instruction with the local filepath to the model you want to import.
1

FROM ./vicuna-33b.Q4_0.gguf
Create the model in Ollama
1

ollama create example -f Modelfile
Run the model
1

ollama run example

Import from Safetensors

See the guide on importing models for more information.

Customize a prompt

Models from the Ollama library can be customized with a prompt. For example, to customize the llama3.2 model:

`1`	`ollama pull llama3.2`

Create a Modelfile:

FROM llama3.2

# set the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1

# set the system message
SYSTEM """
You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
"""

Next, create and run the model:

ollama create mario -f ./Modelfile
ollama run mario
>>> hi
Hello! It's your friend Mario.

For more information on working with a Modelfile, see the Modelfile documentation.

CLI Reference

Create a model

ollama create is used to create a model from a Modelfile.

`1`	`ollama create mymodel -f ./Modelfile`

Pull a model

`1`	`ollama pull llama3.2`

This command can also be used to update a local model. Only the diff will be pulled.

Remove a model

`1`	`ollama rm llama3.2`

Copy a model

`1`	`ollama cp llama3.2 my-model`

Multiline input

For multiline input, you can wrap text with """:

>>> """Hello,
... world!
... """
I'm a basic program that prints the famous "Hello, world!" message to the console.

Multimodal models

`1`	`ollama run llava "What's in this image? /Users/jmorgan/Desktop/smile.png"`

Output: The image features a yellow smiley face, which is likely the central focus of the picture.

Pass the prompt as an argument

`1`	`ollama run llama3.2 "Summarize this file: $(cat README.md)"`

Output: Ollama is a lightweight, extensible framework for building and running language models on the local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications.

Show model information

`1`	`ollama show llama3.2`

List models on your computer

`1`	`ollama list`

List which models are currently loaded

`1`	`ollama ps`

Stop a model which is currently running

`1`	`ollama stop llama3.2`

Start Ollama

ollama serve is used when you want to start ollama without running the desktop application.

Building

See the developer guide

Running local builds

Next, start the server:

`1`	`./ollama serve`

Finally, in a separate shell, run a model:

`1`	`./ollama run llama3.2`

REST API

Ollama has a REST API for running and managing models.

Generate a response

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt":"Why is the sky blue?"
}'

Chat with a model

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    { "role": "user", "content": "why is the sky blue?" }
  ]
}'

See the API documentation for all endpoints.

Community Integrations

Web & Desktop

Open WebUI
SwiftChat (macOS with ReactNative)
Enchanted (macOS native)
Hollama
Lollms-Webui
LibreChat
Bionic GPT
HTML UI
Saddle
TagSpaces (A platform for file-based apps, utilizing Ollama for the generation of tags and descriptions)
Chatbot UI
Chatbot UI v2
Typescript UI
Minimalistic React UI for Ollama Models
Ollamac
big-AGI
Cheshire Cat assistant framework
Amica
chatd
Ollama-SwiftUI
Dify.AI
MindMac
NextJS Web Interface for Ollama
Msty
Chatbox
WinForm Ollama Copilot
NextChat with Get Started Doc
Alpaca WebUI
OllamaGUI
OpenAOE
Odin Runes
LLM-X (Progressive Web App)
AnythingLLM (Docker + MacOs/Windows/Linux native app)
Ollama Basic Chat: Uses HyperDiv Reactive UI
Ollama-chats RPG
IntelliBar (AI-powered assistant for macOS)
Jirapt (Jira Integration to generate issues, tasks, epics)
ojira (Jira chrome plugin to easily generate descriptions for tasks)
QA-Pilot (Interactive chat tool that can leverage Ollama models for rapid understanding and navigation of GitHub code repositories)
ChatOllama (Open Source Chatbot based on Ollama with Knowledge Bases)
CRAG Ollama Chat (Simple Web Search with Corrective RAG)
RAGFlow (Open-source Retrieval-Augmented Generation engine based on deep document understanding)
StreamDeploy (LLM Application Scaffold)
chat (chat web app for teams)
Lobe Chat with Integrating Doc
Ollama RAG Chatbot (Local Chat with multiple PDFs using Ollama and RAG)
BrainSoup (Flexible native client with RAG & multi-agent automation)
macai (macOS client for Ollama, ChatGPT, and other compatible API back-ends)
RWKV-Runner (RWKV offline LLM deployment tool, also usable as a client for ChatGPT and Ollama)
Ollama Grid Search (app to evaluate and compare models)
Olpaka (User-friendly Flutter Web App for Ollama)
Casibase (An open source AI knowledge base and dialogue system combining the latest RAG, SSO, ollama support, and multiple large language models.)
OllamaSpring (Ollama Client for macOS)
LLocal.in (Easy to use Electron Desktop Client for Ollama)
Shinkai Desktop (Two click install Local AI using Ollama + Files + RAG)
AiLama (A Discord User App that allows you to interact with Ollama anywhere in Discord)
Ollama with Google Mesop (Mesop Chat Client implementation with Ollama)
R2R (Open-source RAG engine)
Ollama-Kis (A simple easy-to-use GUI with sample custom LLM for Drivers Education)
OpenGPA (Open-source offline-first Enterprise Agentic Application)
Painting Droid (Painting app with AI integrations)
Kerlig AI (AI writing assistant for macOS)
AI Studio
Sidellama (browser-based LLM client)
LLMStack (No-code multi-agent framework to build LLM agents and workflows)
BoltAI for Mac (AI Chat Client for Mac)
Harbor (Containerized LLM Toolkit with Ollama as default backend)
PyGPT (AI desktop assistant for Linux, Windows, and Mac)
Alpaca (An Ollama client application for Linux and macOS made with GTK4 and Adwaita)
AutoGPT (AutoGPT Ollama integration)
Go-CREW (Powerful Offline RAG in Golang)
PartCAD (CAD model generation with OpenSCAD and CadQuery)
Ollama4j Web UI - Java-based Web UI for Ollama built with Vaadin, Spring Boot, and Ollama4j
PyOllaMx - macOS application capable of chatting with both Ollama and Apple MLX models.
Cline - Formerly known as Claude Dev is a VSCode extension for multi-file/whole-repo coding
Cherry Studio (Desktop client with Ollama support)
ConfiChat (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
Archyve (RAG-enabling document library)
crewAI with Mesop (Mesop Web Interface to run crewAI with Ollama)
Tkinter-based client (Python tkinter-based Client for Ollama)
LLMChat (Privacy focused, 100% local, intuitive all-in-one chat interface)
Local Multimodal AI Chat (Ollama-based LLM Chat with support for multiple features, including PDF RAG, voice chat, image-based interactions, and integration with OpenAI.)
ARGO (Locally download and run Ollama and Huggingface models with RAG and deep research on Mac/Windows/Linux)
OrionChat - OrionChat is a web interface for chatting with different AI providers
G1 (Prototype of using prompting strategies to improve the LLM’s reasoning through o1-like reasoning chains.)
Web management (Web management page)
Promptery (desktop client for Ollama.)
Ollama App (Modern and easy-to-use multi-platform client for Ollama)
chat-ollama (a React Native client for Ollama)
SpaceLlama (Firefox and Chrome extension to quickly summarize web pages with ollama in a sidebar)
YouLama (Webapp to quickly summarize any YouTube video, supporting Invidious as well)
DualMind (Experimental app allowing two models to talk to each other in the terminal or in a web interface)
ollamarama-matrix (Ollama chatbot for the Matrix chat protocol)
ollama-chat-app (Flutter-based chat app)
Perfect Memory AI (Productivity AI assists personalized by what you have seen on your screen, heard, and said in the meetings)
Hexabot (A conversational AI builder)
Reddit Rate (Search and Rate Reddit topics with a weighted summation)
OpenTalkGpt (Chrome Extension to manage open-source models supported by Ollama, create custom models, and chat with models from a user-friendly UI)
VT (A minimal multimodal AI chat app, with dynamic conversation routing. Supports local models via Ollama)
Nosia (Easy to install and use RAG platform based on Ollama)
Witsy (An AI Desktop application available for Mac/Windows/Linux)
Abbey (A configurable AI interface server with notebooks, document storage, and YouTube support)
Minima (RAG with on-premises or fully local workflow)
aidful-ollama-model-delete (User interface for simplified model cleanup)
Perplexica (An AI-powered search engine & an open-source alternative to Perplexity AI)
Ollama Chat WebUI for Docker (Support for local docker deployment, lightweight ollama webui)
AI Toolkit for Visual Studio Code (Microsoft-official VSCode extension to chat, test, evaluate models with Ollama support, and use them in your AI applications.)
MinimalNextOllamaChat (Minimal Web UI for Chat and Model Control)
Chipper AI interface for tinkerers (Ollama, Haystack RAG, Python)
ChibiChat (Kotlin-based Android app to chat with Ollama and Koboldcpp API endpoints)
LocalLLM (Minimal Web-App to run ollama models on it with a GUI)
Ollamazing (Web extension to run Ollama models)
OpenDeepResearcher-via-searxng (A Deep Research equivalent endpoint with Ollama support for running locally)
AntSK (Out-of-the-box & Adaptable RAG Chatbot)
MaxKB (Ready-to-use & flexible RAG Chatbot)
yla (Web interface to freely interact with your customized models)
LangBot (LLM-based instant messaging bots platform, with Agents, RAG features, supports multiple platforms)
1Panel (Web-based Linux Server Management Tool)
AstrBot (User-friendly LLM-based multi-platform chatbot with a WebUI, supporting RAG, LLM agents, and plugins integration)
Reins (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
Flufy (A beautiful chat interface for interacting with Ollama’s API. Built with React, TypeScript, and Material-UI.)
Ellama (Friendly native app to chat with an Ollama instance)
screenpipe Build agents powered by your screen history
Ollamb (Simple yet rich in features, cross-platform built with Flutter and designed for Ollama. Try the web demo.)
Writeopia (Text editor with integration with Ollama)
AppFlowy (AI collaborative workspace with Ollama, cross-platform and self-hostable)
Lumina (A lightweight, minimal React.js frontend for interacting with Ollama servers)
Tiny Notepad (A lightweight, notepad-like interface to chat with ollama available on PyPI)
macLlama (macOS native) (A native macOS GUI application for interacting with Ollama models, featuring a chat interface.)
GPTranslate (A fast and lightweight, AI powered desktop translation application written with Rust and Tauri. Features real-time translation with OpenAI/Azure/Ollama.)
ollama launcher (A launcher for Ollama, aiming to provide users with convenient functions such as ollama server launching, management, or configuration.)
ai-hub (AI Hub supports multiple models via API keys and Chat support via Ollama API.)
Mayan EDMS (Open source document management system to organize, tag, search, and automate your files with powerful Ollama driven workflows.)

Cloud

Terminal

oterm
Ellama Emacs client
Emacs client
neollama UI client for interacting with models from within Neovim
gen.nvim
ollama.nvim
ollero.nvim
ollama-chat.nvim
ogpt.nvim
gptel Emacs client
Oatmeal
cmdh
ooo
shell-pilot(Interact with models via pure shell scripts on Linux or macOS)
tenere
llm-ollama for Datasette’s LLM CLI.
typechat-cli
ShellOracle
tlm
podman-ollama
gollama
ParLlama
Ollama eBook Summary
Ollama Mixture of Experts (MOE) in 50 lines of code
vim-intelligence-bridge Simple interaction of “Ollama” with the Vim editor
x-cmd ollama
bb7
SwollamaCLI bundled with the Swollama Swift package. Demo
aichat All-in-one LLM CLI tool featuring Shell Assistant, Chat-REPL, RAG, AI tools & agents, with access to OpenAI, Claude, Gemini, Ollama, Groq, and more.
PowershAI PowerShell module that brings AI to terminal on Windows, including support for Ollama
DeepShell Your self-hosted AI assistant. Interactive Shell, Files and Folders analysis.
orbiton Configuration-free text editor and IDE with support for tab completion with Ollama.
orca-cli Ollama Registry CLI Application - Browse, pull, and download models from Ollama Registry in your terminal.
GGUF-to-Ollama - Importing GGUF to Ollama made easy (multiplatform)
AWS-Strands-With-Ollama - AWS Strands Agents with Ollama Examples
ollama-multirun - A bash shell script to run a single prompt against any or all of your locally installed ollama models, saving the output and performance statistics as easily navigable web pages. (Demo)
ollama-bash-toolshed - Bash scripts to chat with tool using models. Add new tools to your shed with ease. Runs on Ollama.

Apple Vision Pro

SwiftChat (Cross-platform AI chat app supporting Apple Vision Pro via “Designed for iPad”)
Enchanted

Database

pgai - PostgreSQL as a vector database (Create and search embeddings from Ollama models using pgvector)
- Get started guide
MindsDB (Connects Ollama models with nearly 200 data platforms and apps)
chromem-go with example
Kangaroo (AI-powered SQL client and admin tool for popular databases)

Package managers

Libraries

LangChain and LangChain.js with example
Firebase Genkit
crewAI
Yacana (User-friendly multi-agent framework for brainstorming and executing predetermined flows with built-in tool integration)
Spring AI with reference and example
LangChainGo with example
LangChain4j with example
LangChainRust with example
LangChain for .NET with example
LLPhant
LlamaIndex and LlamaIndexTS
LiteLLM
OllamaFarm for Go
OllamaSharp for .NET
Ollama for Ruby
Ollama-rs for Rust
Ollama-hpp for C++
Ollama4j for Java
ModelFusion Typescript Library
OllamaKit for Swift
Ollama for Dart
Ollama for Laravel
LangChainDart
Semantic Kernel - Python
Haystack
Elixir LangChain
Ollama for R - rollama
Ollama for R - ollama-r
Ollama-ex for Elixir
Ollama Connector for SAP ABAP
Testcontainers
Portkey
PromptingTools.jl with an example
LlamaScript
llm-axe (Python Toolkit for Building LLM Powered Apps)
Gollm
Gollama for Golang
Ollamaclient for Golang
High-level function abstraction in Go
Ollama PHP
Agents-Flex for Java with example
Parakeet is a GoLang library, made to simplify the development of small generative AI applications with Ollama.
Haverscript with examples
Ollama for Swift
Swollama for Swift with DocC
GoLamify
Ollama for Haskell
multi-llm-ts (A Typescript/JavaScript library allowing access to different LLM in a unified API)
LlmTornado (C# library providing a unified interface for major FOSS & Commercial inference APIs)
Ollama for Zig
Abso (OpenAI-compatible TypeScript SDK for any LLM provider)
Nichey is a Python package for generating custom wikis for your research topic
Ollama for D
OllamaPlusPlus (Very simple C++ library for Ollama)

Mobile

SwiftChat (Lightning-fast Cross-platform AI chat app with native UI for Android, iOS, and iPad)
Enchanted
Maid
Ollama App (Modern and easy-to-use multi-platform client for Ollama)
ConfiChat (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
Ollama Android Chat (No need for Termux, start the Ollama service with one click on an Android device)
Reins (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)

Extensions & Plugins

Raycast extension
Discollama (Discord bot inside the Ollama discord channel)
Continue
Vibe (Transcribe and analyze meetings with Ollama)
Obsidian Ollama plugin
Logseq Ollama plugin
NotesOllama (Apple Notes Ollama plugin)
Dagger Chatbot
Discord AI Bot
Ollama Telegram Bot
Hass Ollama Conversation
Rivet plugin
Obsidian BMO Chatbot plugin
Cliobot (Telegram bot with Ollama support)
Copilot for Obsidian plugin
Obsidian Local GPT plugin
Open Interpreter
Llama Coder (Copilot alternative using Ollama)
Ollama Copilot (Proxy that allows you to use Ollama as a copilot like GitHub Copilot)
twinny (Copilot and Copilot chat alternative using Ollama)
Wingman-AI (Copilot code and chat alternative using Ollama and Hugging Face)
Page Assist (Chrome Extension)
Plasmoid Ollama Control (KDE Plasma extension that allows you to quickly manage/control Ollama model)
AI Telegram Bot (Telegram bot using Ollama in backend)
AI ST Completion (Sublime Text 4 AI assistant plugin with Ollama support)
Discord-Ollama Chat Bot (Generalized TypeScript Discord Bot w/ Tuning Documentation)
ChatGPTBox: All in one browser extension with Integrating Tutorial
Discord AI chat/moderation bot Chat/moderation bot written in python. Uses Ollama to create personalities.
Headless Ollama (Scripts to automatically install ollama client & models on any OS for apps that depend on ollama server)
Terraform AWS Ollama & Open WebUI (A Terraform module to deploy on AWS a ready-to-use Ollama service, together with its front-end Open WebUI service.)
node-red-contrib-ollama
Local AI Helper (Chrome and Firefox extensions that enable interactions with the active tab and customisable API endpoints. Includes secure storage for user prompts.)
vnc-lm (Discord bot for messaging with LLMs through Ollama and LiteLLM. Seamlessly move between local and flagship models.)
LSP-AI (Open-source language server for AI-powered functionality)
QodeAssist (AI-powered coding assistant plugin for Qt Creator)
Obsidian Quiz Generator plugin
AI Summmary Helper plugin
TextCraft (Copilot in Word alternative using Ollama)
Alfred Ollama (Alfred Workflow)
TextLLaMA A Chrome Extension that helps you write emails, correct grammar, and translate into any language
Simple-Discord-AI
LLM Telegram Bot (telegram bot, primary for RP. Oobabooga-like buttons, A1111 API integration e.t.c)
mcp-llm (MCP Server to allow LLMs to call other LLMs)
SimpleOllamaUnity (Unity Engine extension for communicating with Ollama in a few lines of code. Also works at runtime)
UnityCodeLama (Unity Edtior tool to analyze scripts via Ollama)
NativeMind (Private, on-device AI Assistant, no cloud dependencies)
GMAI - Gradle Managed AI (Gradle plugin for automated Ollama lifecycle management during build phases)

Supported backends

llama.cpp project founded by Georgi Gerganov.

Observability

Opik is an open-source platform to debug, evaluate, and monitor your LLM applications, RAG systems, and agentic workflows with comprehensive tracing, automated evaluations, and production-ready dashboards. Opik supports native intergration to Ollama.
Lunary is the leading open-source LLM observability platform. It provides a variety of enterprise-grade features such as real-time analytics, prompt templates management, PII masking, and comprehensive agent tracing.
OpenLIT is an OpenTelemetry-native tool for monitoring Ollama Applications & GPUs using traces and metrics.
HoneyHive is an AI observability and evaluation platform for AI agents. Use HoneyHive to evaluate agent performance, interrogate failures, and monitor quality in production.
Langfuse is an open source LLM observability platform that enables teams to collaboratively monitor, evaluate and debug AI applications.
MLflow Tracing is an open source LLM observability tool with a convenient API to log and visualize traces, making it easy to debug and evaluate GenAI applications.

awesome-generative-ai

Sat, 26 Jul 2025 15:30:16 +0800

steven2358/awesome-generative-ai

Awesome Generative AI

A curated list of modern Generative Artificial Intelligence projects and services.

Generative Artificial Intelligence is a technology that creates original content such as images, sounds, and texts by using machine learning algorithms that are trained on large amounts of data. Unlike other forms of AI, it is capable of creating unique and previously unseen outputs such as photorealistic images, digital art, music, and writing. These outputs often have their own unique style and can even be hard to distinguish from human-created works. Generative AI has a wide range of applications in fields such as of art, entertainment, marketing, academia, and computer science.

Contributions to this list are welcome. Before submitting your suggestions, please review the Contribution Guidelines to ensure your entries meet the criteria. Add links through pull requests or create an issue to start a discussion. More projects can be found in the Discoveries List, where we showcase a wide range of up-and-coming Generative AI projects.

Text

Models

OpenAI API - OpenAI’s API provides access to GPT-3 and GPT-4 models, which performs a wide variety of natural language tasks, and Codex, which translates natural language to code.
Gopher - Gopher by DeepMind is a 280 billion parameter language model.
OPT - Open Pretrained Transformers (OPT) by Facebook is a suite of decoder-only pre-trained transformers. Announcement. OPT-175B text generation hosted by Alpa.
Bloom - BLOOM by Hugging Face is a model similar to GPT-3 that has been trained on 46 different languages and 13 programming languages. #opensource
Llama - Meta’s open source large language model. #opensource
Claude - Talk to Claude, an AI assistant from Anthropic.
Vicuna-13B - An open-source chatbot trained by fine-tuning LLaMA on user-shared conversations collected from ShareGPT. #opensource
Mistral - Cutting-edge open-weight LLMs by Mistral AI. #opensource
Grok - An LLM by xAI with open source and open weights. #opensource
Qwen - A series of LLMs independently developed by Alibaba Cloud. #opensource

Chatbots

ChatGPT - ChatGPT by OpenAI is a large language model that interacts in a conversational way.
Copilot - An everyday AI companion by Microsoft.
Gemini - A family of multimodal large language model developed by Google Deepmind.
Meta AI - Meta AI assistant to get things done, create AI-generated images, get answers. Built on Llama LLM.
DeepSeek - Cutting-edge LLMs for enterprise, consumer, and scientific applications. #opensource
Character.AI - Character.AI lets you create characters and chat to them.
Pi - A personalized AI platform available as a digital assistant.
Qwen - Qwen chatbot with image generation, document processing, web search integration, video understanding, etc.
Le Chat - Chat with Mistral AI’s cutting-edge language models.

Custom interfaces

LibreChat - LibreChat is a free and open-source chat interface for assistant AIs. #opensource.
Chatbot UI - An open source ChatGPT UI. #opensource.

Search engines

Perplexity AI - AI powered search tools.
Metaphor - Language model powered search.
Phind - AI-based search engine.
You.com - A search engine built on AI that provides users with a customized search experience while keeping their data 100% private.
Komo - An AI-powered search engine.

Local search engines

privateGPT - Ask questions to your documents without an internet connection, using the power of LLMs.
quivr - Dump all your files and chat with it using your generative AI second brain using LLMs & embeddings.

Writing assistants

Jasper - Create content faster with artificial intelligence.
Compose AI - Compose AI is a free Chrome extension that cuts your writing time by 40% with AI-powered autocompletion.
Rytr - Rytr is an AI writing assistant that helps you create high-quality content.
wordtune - Personal writing assistant.
HyperWrite - HyperWrite helps you write with confidence and get your work done faster from idea to final draft.
Moonbeam - Better blogs in a fraction of the time.
copy.ai - Write better marketing copy and content with AI.
ChatSonic - An AI-powered assistant that enables text and image creation.
Anyword - Anyword’s AI writing assistant generates effective copy for anyone.
Hypotenuse AI - Turn a few keywords into original, insightful articles, product descriptions and social media copy.
Lavender - Lavender email assistant helps you get more replies in less time.
Lex - A word processor with artificial intelligence baked in, so you can write faster.
Jenni - Jenni is the ultimate writing assistant that saves you hours of ideation and writing time.
LAIKA - LAIKA trains an artificial intelligence on your own writing to create a personalised creative partner-in-crime.
QuillBot - AI-powered paraphrasing tool.
Postwise - Write tweets, schedule posts and grow your following using AI.
Copysmith - AI content creation solution for Enterprise & eCommerce.

ChatGPT extensions

WebChatGPT - Augment your ChatGPT prompts with relevant results from the web.
GPT for Sheets and Docs - ChatGPT extension for Google Sheets and Google Docs.
YouTube Summary with ChatGPT - Use ChatGPT to summarize YouTube videos.
ChatGPT Prompt Genius - Discover, share, import, and use the best prompts for ChatGPT & save your chat history locally.
ChatGPT for Search Engines - Display ChatGPT response alongside Google, Bing, and DuckDuckGo search results.
ShareGPT - Share your ChatGPT conversations and explore conversations shared by others.
Merlin - ChatGPT Plus extension on all websites.
ChatGPT Writer - Generate entire emails and messages using ChatGPT AI.
ChatGPT for Jupyter - Add various helper functions in Jupyter Notebooks and Jupyter Lab, powered by ChatGPT.
editGPT - Easily proofread, edit, and track changes to your content in chatGPT.
Forefront - A Better ChatGPT Experience.

Productivity

ChatPDF - Chat with any PDF.
Mem - Mem is the world’s first AI-powered workspace that’s personalized to you. Amplify your creativity, automate the mundane, and stay organized automatically.
Taskade - Outline tasks, notes, generated structured lists and mind maps with Taskade AI.
Notion AI - Write better, more efficient notes and docs.
Nekton AI - Automate your workflows with AI. Describe your workflows step by step in plain language.
Rewind - Rewind is a personalized AI powered by everything you’ve seen, said, or heard.
NotebookLM - A research and note-taking online tool to interact with documents, powered by Google Gemini.

Meeting assistants

Otter.ai - A meeting assistant that records audio, writes notes, automatically captures slides, and generates summaries.
Cogram - Cogram takes automatic notes in virtual meetings and identifies action items.
Sybill - Sybill generates summaries of sales calls, including next steps, pain points and areas of interest, by combining transcript and emotion-based insights.
Loopin AI - Loopin is a collaborative meeting workspace that not only enables you to record, transcribe & summaries meetings using AI, but also enables you to auto-organise meeting notes on top of your calendar.
Fireflies.ai - Fireflies.ai helps your team transcribe, summarize, search, and analyze voice conversations.
Read AI - An AI copilot for wherever you work, making your meetings, emails, and messages more productive with summaries, content discovery, and recommendations.
Fireflies.ai - Transcribe, summarize, search, and analyze all your team conversations.

Academia

Elicit - Elicit uses language models to help you automate research workflows, like parts of literature review.
genei - Summarise academic articles in seconds and save 80% on your research times.
Explainpaper - A better way to read academic papers. Upload a paper, highlight confusing text, get an explanation.
Galactica - A large language model for science. Can summarize academic literature, solve math problems, generate Wiki articles, write scientific code, annotate molecules and proteins, and more. Model API.
Consensus - Consensus is a search engine that uses AI to find answers in scientific research.
Synthical - AI-powered collaborative research environment.
scite - A platform for discovering and evaluating scientific articles.
SciSpace - An AI research assistant for understanding scientific literature.
STORM - An LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations. #opensource

Leaderboards

Chatbot Arena - An open platform for crowdsourced AI benchmarking, hosted by researchers at UC Berkeley SkyLab and LMArena.
Artificial Analysis - Artificial Analysis provides objective benchmarks & information to help choose AI models and hosting providers.
imgsys - A generative image model arena by fal.ai.

Other text generators

EmailTriager - Use AI to automatically draft email replies in the background.
AI Poem Generator - AI Poem Generator writes a beautiful rhyming poem for you on any subject, given a text prompt.

Coding

Coding Assistants

GitHub Copilot - GitHub Copilot uses the OpenAI Codex to suggest code and entire functions in real-time, right from your editor.
OpenAI Codex - An AI system by OpenAI that translates natural language to code.
Ghostwriter - An AI-powered pair programmer by replit.
Amazon Q - The AWS generative AI–powered assistant that helps answer questions, write code, and automate tasks.
tabnine - Code faster with whole-line & full-function code completions.
Stenography - Automatic code documentation.
Mintlify - AI powered documentation writer.
Debuild - AI-powered low-code tool for web apps.
AI2sql - With AI2sql, engineers and non-engineers can easily write efficient, error-free SQL queries without knowing SQL.
CodiumAI - With CodiumAI, you get non-trivial tests suggested right inside your IDE, so you stay confident when you push.
PR-Agent - AI-powered tool for automated PR analysis, feedback, suggestions and more.
MutableAI - AI Accelerated Software Development.
TurboPilot - A self-hosted copilot clone which uses the library behind llama.cpp to run the 6 billion parameter Salesforce Codegen model in 4 GB of RAM.
GPT-Code UI - An open source implementation of OpenAI’s ChatGPT Code interpreter. #opensource
MetaGPT - The Multi-Agent Framework: Given one line Requirement, return PRD, Design, Tasks, Repo
Open Interpreter - OpenAI’s Code Interpreter in your terminal, running locally.
Continue - Open-source AI code assistant. Connect any model and any context to create custom autocomplete and chat experiences inside the IDE. #opensource

Developer tools

co:here - Cohere provides access to advanced Large Language Models and NLP tools.
Haystack - A framework for building NLP applications (e.g. agents, semantic search, question-answering) with language models.
LangChain - A framework for developing applications powered by language models.
gpt4all - A chatbot trained on a massive collection of clean assistant data including code, stories and dialogue.
LLM App - Open-source Python library to build real-time LLM-enabled data pipeline.
LMQL - LMQL is a query language for large language models.
LlamaIndex - A data framework for building LLM applications over external data.
Phoenix - Open-source tool for ML observability that runs in your notebook environment, by Arize. Monitor and fine tune LLM, CV and tabular models.
Cursor - Cursor is the IDE of the future, built for pair-programming with Powerful AI.
SymbolicAI - A neuro-symbolic framework for building applications with LLMs at the core.
Vanna.ai - An open-source Python RAG framework for SQL generation and related functionality. #opensource
Portkey - A full-stack LLMOps platform for LLM monitoring, caching, and management.
agenta - An open-source end-to-end LLMOps platform for prompt engineering, evaluation, and deployment. #opensource
Together AI - Train, fine-tune-and run inference on AI models blazing fast, at low cost, and at production scale.
Gitingest - Turn any Git repository into a simple text digest of its codebase so it can be fed into any LLM. #opensource
Repomix - Pack your codebase into AI-friendly formats. #opensource
llama.cpp - Inference of Meta’s LLaMA model (and others) in pure C/C++. #opensource
bitnet.cpp - Official inference framework for 1-bit LLMs, by Microsoft. #opensource
OpenRouter - A unified interface for LLMs. #opensource
Ludwig - A low-code framework for building custom AI models like LLMs and other deep neural networks. #opensource

Playgrounds

OpenAI Playground - Explore resources, tutorials, API docs, and dynamic examples.
Google AI Studio - A web-based tool to prototype with Gemini and experimental models.
GitHub Models - Find and experiment with AI models to develop a generative AI application.

Local LLM Deployment

Ollama - Get up and running with large language models locally.
Open WebUI - An extensible, feature-rich, and user-friendly self-hosted AI platform designed to operate entirely offline. #opensource
Jan - Run LLMs like Mistral or Llama2 locally and offline on your computer, or connect to remote AI APIs. #opensource
Msty - A straightworward and powerful interface for local and online AI models.
PyGPT - Personal desktop AI assistant with chat, vision, agents, image generation, tools and commands, voice control and more. #opensource
LLM - A CLI utility and Python library for interacting with Large Language Models, remote and local. #opensource

Agents

Autonomous agents

Auto-GPT - An experimental open-source attempt to make GPT-4 fully autonomous.
babyagi - An AI-powered task management system.
AgentGPT - Assemble, configure, and deploy autonomous AI Agents in your browser.
GPT Engineer - Specify what you want it to build, the AI asks for clarification, and then builds it.
GPT Prompt Engineer - Automated prompt engineering. It generates, tests, and ranks prompts to find the best ones.
MetaGPT - The Multi-Agent Framework: Given one line requirement, return PRD, design, tasks, repo.
AutoGen - AutoGen is a framework that enables the development of LLM applications using multiple agents that can converse with each other to solve tasks.
GPT Pilot - Dev tool that writes scalable apps from scratch while the developer oversees the implementation.
Devin - An autonomous AI software engineer by Cognition Labs.
OpenDevin - An autonomous agent designed to navigate the complexities of software engineering. #opensource
Davika - An agentic AI software engineer. #opensource

Custom assistants

Poe - Poe gives access to a variety of bots.
GPT Builder - Assistant for creating GPT-based assistants.
GPTStore - Find useful GPTs. Share your own GPTs.

Image

Models

DALL·E 2 - DALL·E 2 by OpenAI is a new AI system that can create realistic images and art from a description in natural language.
Stable Diffusion - Stable Diffusion by Stability AI is a state of the art text-to-image model that generates images from text. #opensource
Midjourney - Midjourney is an independent research lab exploring new mediums of thought and expanding the imaginative powers of the human species.
Imagen - Imagen by Google is a text-to-image diffusion model with an unprecedented degree of photorealism and a deep level of language understanding.
Make-A-Scene - Make-A-Scene by Meta is a multimodal generative AI method puts creative control in the hands of people who use it by allowing them to describe and illustrate their vision through both text descriptions and freeform sketches.
DragGAN - Drag Your GAN: Interactive Point-based Manipulation on the Generative Image Manifold.

Services

Craiyon - Craiyon, formerly DALL-E mini, is an AI model that can draw images from any text prompt.
DreamStudio - DreamStudio is an easy-to-use interface for creating images using the Stable Diffusion image generation model.
Artbreeder - Artbreeder is new type of creative tool that empowers users creativity by making it easier to collaborate and explore.
GauGAN2 - GauGAN2 is a robust tool for creating photorealistic art using a combination of words and drawings since it integrates segmentation mapping, inpainting, and text-to-image production in a single model.
Magic Eraser - Remove unwanted things from images in seconds.
Imagine by Magic Studio - A tool by Magic Studio that let’s you express yourself by just describing what’s on your mind.
Alpaca - Stable Diffusion Photoshop plugin.
Patience.ai - Patience.ai is an app for creating images with Stable Diffusion, a cutting edge AI developed by Stability.AI.
GenShare - Generate art in seconds for free. Own and share what you create. A multimedia generative studio, democratizing design and creativity.
Playground - Playground is a free-to-use online AI image creator. Use it to create art, social media posts, presentations, posters, videos, logos and more.
Pixelz AI Art Generator - Pixelz AI Art Generator enables you to create incredible art from text. Stable Diffusion, CLIP Guided Diffusion & PXL·E realistic algorithms available.
modyfi - The image editor you’ve always wanted. AI-powered creative tools in your browser. Real-time collaboration.
Ponzu - Ponzu is your free AI logo generator. Build your brand with creatively designed logos in seconds, using only your imagination.
PhotoRoom - Create product and portrait pictures using only your phone. Remove background, change background and showcase products.
Avatar AI - Create your own AI-generated avatars.
ClipDrop - Create professional visuals without a photo studio, powered by stability.ai.
Lensa - An all-in-one image editing app that includes the generation of personalized avatars using Stable Diffusion.
RunDiffusion - Cloud-based workspace for creating AI-generated art.
Ideogram - A text-to-image platform to make creative expression more accessible.
Bing Image Creator - DALLE·3 based text-to-image generator with safety features.
KREA - Generate high quality visuals with an AI that knows about your styles, concepts, or products.
Nightcafe - NightCafe Creator is an AI Art Generator app with multiple methods of AI art generation.
Leonardo AI - Create production-quality visual assets for your projects with unprecedented quality, speed, and style.
Recraft - An AI tool that lets creators easily generate and iterate original images, vector art, illustrations, icons, and 3D graphics.
Reve Image - A model trained from the ground up to excel at prompt adherence, aesthetics, and typography.

Graphic design

Brandmark - AI-based logo design tool.
Gamma - Create beautiful presentations and webpages with none of the formatting and design work.
Microsoft Designer - Stunning designs in a flash.

Image libraries

Lexica - Stable Diffusion search engine.
OpenArt - Search 10M+ of prompts, and generate AI art via Stable Diffusion, DALL·E 2.
PromptHero - Search prompts for models like Stable Diffusion, ChatGPT, Midjourney, etc.
PromptBase - Search prompts from top prompt engineers. Sell your own prompts.

Model libraries

Civitai - Community driven AI model sharing tool.
Stable Diffusion Models - A comprehensive list of Stable Diffusion checkpoints on rentry.org.

Stable Diffusion resources

Stable Horde - A crowdsourced distributed cluster of Stable Diffusion workers.
DiffusionDB - A list of all public apps, developer tools, guides and plugins for Stable Diffusion. Airtable version.
PublicPrompts - A collection of free prompts for Stable Diffusion.
Stableboost - Stableboost is a Stable Diffusion WebUI that lets you quickly generate a lot of images so you can find the perfect ones.
Hugging Face Diffusion Models Course - Python materials for the online course on diffusion models by @huggingface.

Video

Runway - Magical AI tools, realtime collaboration, precision editing, and more. Your next-generation content creation suite.
Synthesia - Create videos from plain text in minutes.
Rephrase AI - Rephrase’s technology enables hyper-personalized video creation at scale that drive engagement and business efficiencies.
Hour One - Turn text into video, featuring virtual presenters, automatically.
Colossyan - Learning & Development focused video creator. Use AI avatars to create educational videos in multiple languages.
Fliki - Create text to video and text to speech content with ai powered voices in minutes.
Pictory - Pictory’s powerful AI enables you to create and edit professional quality videos using text.
Pika - An idea-to-video platform that brings your creativity to motion.
Sora - An AI model that can create realistic and imaginative scenes from text instructions.
Luma Dream Machine - An AI model that makes high quality, realistic videos fast from text and images.
Infinity AI - Infinity is a video foundation model that allows you to craft your characters and then bring them to life.
KLING AI - Tools for creating imaginative images and videos.
Hailuo AI - AI-powered text-to-video generator.

Avatars

D-ID - Create and interact with talking avatars at the touch of a button.
HeyGen - Turn scripts into talking videos with customizable AI avatars in minutes.
RenderNet - RenderNet AI is a tool for generating images and videos, providing control over character design, composition, and style.

Animation

Wonder Dynamics - Effortlessly animate, light, and compose CG characters into live scenes.

Audio

Text-to-speech

Eleven Labs - AI voice generator.
Resemble AI - AI voice generator and voice cloning for text to speech.
WellSaid - Convert text to voice in real time.
Play.ht - AI Voice Generator. Generate realistic Text to Speech voice over online with AI. Convert text to audio.
podcast.ai - A podcast that is entirely generated by artificial intelligence, powered by Play.ht text-to-voice AI.
VALL-E X - A cross-lingual neural codec language model for cross-lingual speech synthesis.
TorToiSe - A multi-voice text-to-speech system trained with an emphasis on quality. #opensource
Bark - A transformer-based text-to-audio model. #opensource

Speech-to-text

Whisper - Robust speech recognition via large-scale weak supervision. #opensource
Wispr Flow - Flow makes writing quick with seamless voice dictation for any application on your computer.
Vibe Transcribe - All-in-one solution for effortless audio and video transcription. #opensource
whisper.cpp - Port of OpenAI’s Whisper model in C/C++. #opensource

Music

Harmonai - We are a community-driven organization releasing open-source generative audio tools to make music production more accessible and fun for everyone.
Mubert - A royalty-free music ecosystem for content creators, brands and developers.
MusicLM - A model by Google Research for generating high-fidelity music from text descriptions.
AudioCraft - A single-stop code base for generative audio needs, by Meta. Includes MusicGen for music and AudioGen for sounds. #opensource
Stable Audio - Stable Audio is Stability AI’s first product for music and sound effect generation.
AIVA - AI-based music generation assistant. Choose from 250+ styles.
Suno AI - Anyone can make great music. No instrument needed, just imagination. From your mind to music.
Udio - Discover, create, and share music with the world.

Other

Diagram - Magical new ways to design products.
PromptBase - A marketplace for buying and selling quality prompts for DALL·E, GPT-3, Midjourney, Stable Diffusion.
This Image Does Not Exist - Test your ability to tell if an image is human or computer generated.
Have I Been Trained? - Check if your image has been used to train popular AI art models.
AI Dungeon - A text-based adventure-story game you direct (and star in) while the AI brings it to life.
Clickable - Generate ads in seconds with AI. Beautiful, brand-consistent, and highly converting ads for all marketing channels.
Scale Spellbook - Build, compare, and deploy large language model apps with Scale Spellbook.
Scenario - AI-generated gaming assets.
Teleprompter - An on-device AI for your meetings that listens to you and makes charismatic quote suggestions.
FinChat - Using AI, FinChat generates answers to questions about public companies and investors.
Morpher AI - Morpher AI delivers real-time insights and analysis for any market.
Whimsical AI - GPT-powered mind mapping, flowcharts, and visual tools for rapid idea development and process organization.

Learning resources

Learn Prompting - A free, open source course on communicating with artificial intelligence.
Prompt Engineering Guide - Guide and resources for prompt engineering.
ChatGPT prompt engineering for developers - A short course by Isa Fulford (OpenAI) and Andrew Ng (DeepLearning.AI).
OpenAI Cookbook - Examples and guides for using the OpenAI API.
OpenAI Prompt Engineering Guide - Strategies and tactics for getting better results from large language models.
PromptPerfect - Tool for prompt engineering.
Anthropic courses - Anthropic’s educational courses.
Build a Large Language Model (From Scratch) - A guide to building your own working LLM, by Sebastian Raschka.

More lists

Tools and Resources for AI Art - A large list of Google Colab notebooks for generative AI, by @pharmapsychotic.
The Generative AI Application Landscape - An infographic that maps the generative AI ecosystem, by Sonya Huang of Sequioa Capital.
Startups - @builtwithgenai - An Airtable list by @builtwithgenai.
The Generative AI Index - An Airtable list by Scale Venture Partners.
Generative AI for Games - A market map of companies working on Generative AI for games, by a16z.
Generative Deep Art - A curated list of generative deep learning tools, works, models, etc. for artistic uses, by @filipecalegario.
GPT-3 Demo - Showcase with GPT-3 examples, demos, apps, showcase, and NLP use-cases.
GPT-4 Demo - GPT-4 apps and use-cases.
The Generative AI Landscape - A Collection of Awesome Generative AI Applications.
Molecular design - List of molecular design using Generative AI and Deep Learning.
Open LLMs - A list of open LLMs available for commercial use.

Lists on ChatGPT

Awesome ChatGPT - A curated list of awesome tools, demos, docs for ChatGPT and GPT-3, by @jordn.
Awesome ChatGPT Prompts - A collection of prompt examples to be used with the ChatGPT model.
FlowGPT - Amplify your workflow with the best prompts.
ChatGPT Prompts for Data Science - A repository of useful data science prompts for ChatGPT.
Awesome ChatGPT - Another awesome list for ChatGPT.

rag-from-scratch

Fri, 25 Jul 2025 15:33:48 +0800

langchain-ai/rag-from-scratch

RAG From Scratch

LLMs are trained on a large but fixed corpus of data, limiting their ability to reason about private or recent information. Fine-tuning is one way to mitigate this, but is often not well-suited for factual recall and can be costly. Retrieval augmented generation (RAG) has emerged as a popular and powerful mechanism to expand an LLM’s knowledge base, using documents retrieved from an external data source to ground the LLM generation via in-context learning. These notebooks accompany a video playlist that builds up an understanding of RAG from scratch, starting with the basics of indexing, retrieval, and generation.

Video playlist

servers

Wed, 11 Jun 2025 15:30:18 +0800

modelcontextprotocol/servers

Model Context Protocol servers

This repository is a collection of reference implementations for the Model Context Protocol (MCP), as well as references to community built servers and additional resources.

The servers in this repository showcase the versatility and extensibility of MCP, demonstrating how it can be used to give Large Language Models (LLMs) secure, controlled access to tools and data sources. Each MCP server is implemented with either the Typescript MCP SDK or Python MCP SDK.

Note: Lists in this README are maintained in alphabetical order to minimize merge conflicts when adding new items.

🌟 Reference Servers

These servers aim to demonstrate MCP features and the TypeScript and Python SDKs.

Everything - Reference / test server with prompts, resources, and tools
Fetch - Web content fetching and conversion for efficient LLM usage
Filesystem - Secure file operations with configurable access controls
Git - Tools to read, search, and manipulate Git repositories
Memory - Knowledge graph-based persistent memory system
Sequential Thinking - Dynamic and reflective problem-solving through thought sequences
Time - Time and timezone conversion capabilities

Archived

The following reference servers are now archived and can be found at servers-archived.

AWS KB Retrieval - Retrieval from AWS Knowledge Base using Bedrock Agent Runtime
Brave Search - Web and local search using Brave’s Search API
EverArt - AI image generation using various models
GitHub - Repository management, file operations, and GitHub API integration
GitLab - GitLab API, enabling project management
Google Drive - File access and search capabilities for Google Drive
Google Maps - Location services, directions, and place details
PostgreSQL - Read-only database access with schema inspection
Puppeteer - Browser automation and web scraping
Redis - Interact with Redis key-value stores
Sentry - Retrieving and analyzing issues from Sentry.io
Slack - Channel management and messaging capabilities
Sqlite - Database interaction and business intelligence capabilities

🤝 Third-Party Servers

🎖️ Official Integrations

Official integrations are maintained by companies building production ready MCP servers for their platforms.

21st.dev Magic - Create crafted UI components inspired by the best 21st.dev design engineers.
Adfin - The only platform you need to get paid - all payments in one place, invoicing and accounting reconciliations with Adfin.
AgentQL - Enable AI agents to get structured data from unstructured web with AgentQL.
AgentRPC - Connect to any function, any language, across network boundaries using AgentRPC.
Aiven - Navigate your Aiven projects and interact with the PostgreSQL®, Apache Kafka®, ClickHouse® and OpenSearch® services
Alation - Unlock the power of the enterprise Data Catalog by harnessing tools provided by the Alation MCP server.
Algolia MCP Algolia MCP Server exposes a natural language interface to query, inspect, and manage Algolia indices and configs. Useful for monitoring, debugging and optimizing search performance within your agentic workflows. See demo.
Alibaba Cloud RDS - An MCP server designed to interact with the Alibaba Cloud RDS OpenAPI, enabling programmatic management of RDS resources via an LLM.
Alibaba Cloud AnalyticDB for MySQL - Connect to a AnalyticDB for MySQL cluster for getting database or table metadata, querying and analyzing data.It will be supported to add the openapi for cluster operation in the future.
Alibaba Cloud OPS - Manage the lifecycle of your Alibaba Cloud resources with CloudOps Orchestration Service and Alibaba Cloud OpenAPI.
Alibaba Cloud OpenSearch - This MCP server equips AI Agents with tools to interact with OpenSearch through a standardized and extensible interface.
Apache IoTDB - MCP Server for Apache IoTDB database and its tools
Apify - Actors MCP Server: Use 3,000+ pre-built cloud tools to extract data from websites, e-commerce, social media, search engines, maps, and more
APIMatic MCP - APIMatic MCP Server is used to validate OpenAPI specifications using APIMatic. The server processes OpenAPI files and returns validation summaries by leveraging APIMatic’s API.
Apollo MCP Server - Connect your GraphQL APIs to AI agents
Arize Phoenix - Inspect traces, manage prompts, curate datasets, and run experiments using Arize Phoenix, an open-source AI and LLM observability tool.
Asgardeo - MCP server to interact with your Asgardeo organization through LLM tools.
Astra DB - Comprehensive tools for managing collections and documents in a DataStax Astra DB NoSQL database with a full range of operations such as create, update, delete, find, and associated bulk actions.
Atlan - The Atlan Model Context Protocol server allows you to interact with the Atlan services through multiple tools.
Audiense Insights - Marketing insights and audience analysis from Audiense reports, covering demographic, cultural, influencer, and content engagement analysis.
AWS - Specialized MCP servers that bring AWS best practices directly to your development workflow.
Axiom - Query and analyze your Axiom logs, traces, and all other event data in natural language
Azure - The Azure MCP Server gives MCP Clients access to key Azure services and tools like Azure Storage, Cosmos DB, the Azure CLI, and more.
Bankless Onchain - Query Onchain data, like ERC20 tokens, transaction history, smart contract state.
BICScan - Risk score / asset holdings of EVM blockchain address (EOA, CA, ENS) and even domain names.
Bitrise - Chat with your builds, CI, and more.
Box - Interact with the Intelligent Content Management platform through Box AI.
Browserbase - Automate browser interactions in the cloud (e.g. web navigation, data extraction, form filling, and more)
BrowserStack - Access BrowserStack’s Test Platform to debug, write and fix tests, do accessibility testing and more.
Burp Suite - MCP Server extension allowing AI clients to connect to Burp Suite
Cartesia - Connect to the Cartesia voice platform to perform text-to-speech, voice cloning etc.
Chargebee - MCP Server that connects AI agents to Chargebee platform.
Chiki StudIO - Create your own configurable MCP servers purely via configuration (no code), with instructions, prompts, and tools support.
Chroma - Embeddings, vector search, document storage, and full-text search with the open-source AI application database
Chronulus AI - Predict anything with Chronulus AI forecasting and prediction agents.
CircleCI - Enable AI Agents to fix build failures from CircleCI.
ClickHouse - Query your ClickHouse database server.
Cloudflare - Deploy, configure & interrogate your resources on the Cloudflare developer platform (e.g. Workers/KV/R2/D1)
Codacy - Interact with Codacy API to query code quality issues, vulnerabilities, and coverage insights about your code.
CodeLogic - Interact with CodeLogic, a Software Intelligence platform that graphs complex code and data architecture dependencies, to boost AI accuracy and insight.
Comet Opik - Query and analyze your Opik logs, traces, prompts and all other telemtry data from your LLMs in natural language.
Confluent - Interact with Confluent Kafka and Confluent Cloud REST APIs.
Convex - Introspect and query your apps deployed to Convex.
Couchbase - Interact with the data stored in Couchbase clusters.
CRIC Wuye AI - Interact with capabilities of the CRIC Wuye AI platform, an intelligent assistant specifically for the property management industry.
Dart - Interact with task, doc, and project data in Dart, an AI-native project management tool
DataHub - Search your data assets, traverse data lineage, write SQL queries, and more using DataHub metadata.
DexPaprika (CoinPaprika) - Access real-time DEX data, liquidity pools, token information, and trading analytics across multiple blockchain networks with DexPaprika by CoinPaprika.
DevHub - Manage and utilize website content within the DevHub CMS platform
DevRev - An MCP server to integrate with DevRev APIs to search through your DevRev Knowledge Graph where objects can be imported from diff. Sources listed here.
Dynatrace - Manage and interact with the Dynatrace Platform for real-time observability and monitoring.
E2B - Run code in secure sandboxes hosted by E2B
Edgee - Deploy and manage Edgee components and projects
EduBase - Interact with EduBase, a comprehensive e-learning platform with advanced quizzing, exam management, and content organization capabilities
Elasticsearch - Query your data in Elasticsearch
eSignatures - Contract and template management for drafting, reviewing, and sending binding contracts.
Exa - Search Engine made for AIs by Exa
Fewsats - Enable AI Agents to purchase anything in a secure way using Fewsats
Fibery - Perform queries and entity operations in your Fibery workspace.
Financial Datasets - Stock market API made for AI agents
Firecrawl - Extract web data with Firecrawl
Fireproof - Immutable ledger database with live synchronization
Github - GitHub’s official MCP Server
GibsonAI - AI-Powered Cloud databases: Build, migrate, and deploy database instances with AI
Gitea - Interact with Gitea instances with MCP.
Gitee - Gitee API integration, repository, issue, and pull request management, and more.
Glean - Enterprise search and chat using Glean’s API.
Gyazo - Search, fetch, upload, and interact with Gyazo images, including metadata and OCR data.
gotoHuman - Human-in-the-loop platform - Allow AI agents and automations to send requests for approval to your gotoHuman inbox.
Grafana - Search dashboards, investigate incidents and query datasources in your Grafana instance
Grafbase - Turn your GraphQL API into an efficient MCP server with schema intelligence in a single command.
Graphlit - Ingest anything from Slack to Gmail to podcast feeds, in addition to web crawling, into a searchable Graphlit project.
GreptimeDB - Provides AI assistants with a secure and structured way to explore and analyze data in GreptimeDB.
Heroku - Interact with the Heroku Platform through LLM-driven tools for managing apps, add-ons, dynos, databases, and more.
Hologres - Connect to a Hologres instance, get table metadata, query and analyze data.
Honeycomb Allows Honeycomb Enterprise customers to query and analyze their data, alerts, dashboards, and more; and cross-reference production behavior with the codebase.
HubSpot - Connect, manage, and interact with HubSpot CRM data
Hyperbrowser - Hyperbrowser is the next-generation platform empowering AI agents and enabling effortless, scalable browser automation.
IBM wxflows - Tool platform by IBM to build, test and deploy tools for any data source
ForeverVM - Run Python in a code sandbox.
Inbox Zero - AI personal assistant for email Inbox Zero
Inkeep - RAG Search over your content powered by Inkeep
Integration App - Interact with any other SaaS applications on behalf of your customers.
JetBrains – Work on your code with JetBrains IDEs
Kagi Search - Search the web using Kagi’s search API
Keboola - Build robust data workflows, integrations, and analytics on a single intuitive platform.
Klavis ReportGen - Create professional reports from a simple user query.
KWDB - Reading, writing, querying, modifying data, and performing DDL operations with data in your KWDB Database.
Lara Translate - MCP Server for Lara Translate API, enabling powerful translation capabilities with support for language detection and context-aware translations.
Logfire - Provides access to OpenTelemetry traces and metrics through Logfire.
Langfuse Prompt Management - Open-source tool for collaborative editing, versioning, evaluating, and releasing prompts.
LaunchDarkly - LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely.
Linear - Search, create, and update Linear issues, projects, and comments.
Lingo.dev - Make your AI agent speak every language on the planet, using Lingo.dev Localization Engine.
Litmus.io - Official MCP server for configuring Litmus Edge for Industrial Data Collection, Edge Analytics & Industrial AI.
Mailgun - Interact with Mailgun API.
Make - Turn your Make scenarios into callable tools for AI assistants.
MCP Toolbox for Databases - Open source MCP server specializing in easy, fast, and secure tools for Databases. Supports AlloyDB, BigQuery, Bigtable, Cloud SQL, Dgraph, MySQL, Neo4j, Postgres, Spanner, and more.
Meilisearch - Interact & query with Meilisearch (Full-text & semantic search API)
Memgraph - Query your data in Memgraph graph database.
Metoro - Query and interact with kubernetes environments monitored by Metoro
Mercado Pago - Mercado Pago’s official MCP server.
Microsoft Clarity - Official MCP Server to get your behavioral analytics data and insights from Clarity
Microsoft Dataverse - Chat over your business data using NL - Discover tables, run queries, retrieve data, insert or update records, and execute custom prompts grounded in business knowledge and context.
Milvus - Search, Query and interact with data in your Milvus Vector Database.
Momento - Momento Cache lets you quickly improve your performance, reduce costs, and handle load at any scale.
MongoDB - Both MongoDB Community Server and MongoDB Atlas are supported.
MotherDuck - Query and analyze data with MotherDuck and local DuckDB
Needle - Production-ready RAG out of the box to search and retrieve data from your own documents.
Neo4j - Neo4j graph database server (schema + read/write-cypher) and separate graph database backed memory
Neon - Interact with the Neon serverless Postgres platform
Netlify - Create, build, deploy, and manage your websites with Netlify web platform.
Notion - This project implements an MCP server for the Notion API.
OceanBase - MCP Server for OceanBase database and its tools
Octagon - Deliver real-time investment research with extensive private and public market data.
OlaMaps - Official Ola Maps MCP Server for services like geocode, directions, place details and many more.
OP.GG - Access real-time gaming data across popular titles like League of Legends, TFT, and Valorant, offering champion analytics, esports schedules, meta compositions, and character statistics.
OpsLevel - Official MCP Server for OpsLevel.
Oxylabs - Scrape websites with Oxylabs Web API, supporting dynamic rendering and parsing for structured data extraction.
Paddle - Interact with the Paddle API. Manage product catalog, billing and subscriptions, and reports.
Pagos - Interact with the Pagos API. Query Credit Card BIN Data with more to come.
PayPal - PayPal’s official MCP server.
Perplexity - An MCP server that connects to Perplexity’s Sonar API, enabling real-time web-wide research in conversational AI.
Pinecone - Pinecone’s developer MCP Server assist developers in searching documentation and managing data within their development environment.
Pinecone Assistant - Retrieves context from your Pinecone Assistant knowledge base.
Prisma - Create and manage Prisma Postgres databases
Pulumi - Deploy and manage cloud infrastructure using Pulumi.
Pure.md - Reliably access web content in markdown format with pure.md (bot detection avoidance, proxy rotation, and headless JS rendering built in).
Put.io - Interact with your Put.io account to download torrents.
Ragie - Retrieve context from your Ragie (RAG) knowledge base connected to integrations like Google Drive, Notion, JIRA and more.
Redis - The Redis official MCP Server offers an interface to manage and search data in Redis.
Redis Cloud API - The Redis Cloud API MCP Server allows you to manage your Redis Cloud resources using natural language.
Snyk - Enhance security posture by embedding Snyk vulnerability scanning directly into agentic workflows.
Qdrant - Implement semantic memory layer on top of the Qdrant vector search engine
Ramp - Interact with Ramp’s Developer API to run analysis on your spend and gain insights leveraging LLMs
Raygun - Interact with your crash reporting and real using monitoring data on your Raygun account
Rember - Create spaced repetition flashcards in Rember to remember anything you learn in your chats
Riza - Arbitrary code execution and tool-use platform for LLMs by Riza
Root Signals - Improve and quality control your outputs with evaluations using LLM-as-Judge
Search1API - One API for Search, Crawling, and Sitemaps
ScreenshotOne - Render website screenshots with ScreenshotOne
Semgrep - Enable AI agents to secure code with Semgrep.
SingleStore - Interact with the SingleStore database platform
StarRocks - Interact with StarRocks
Stripe - Interact with Stripe API
Tavily - Search engine for AI agents (search + extract) powered by Tavily
Terraform - Seamlessly integrate with Terraform ecosystem, enabling advanced automation and interaction capabilities for Infrastructure as Code (IaC) development powered by Terraform
Thirdweb - Read/write to over 2k blockchains, enabling data querying, contract analysis/deployment, and transaction execution, powered by Thirdweb
Tianji - Interact with Tianji platform whatever selfhosted or cloud platform, powered by Tianji.
TiDB - MCP Server to interact with TiDB database platform.
Tinybird - Interact with Tinybird serverless ClickHouse platform
Tldv - Connect your AI agents to Google-Meet, Zoom & Microsoft Teams through tl;dv
UnifAI - Dynamically search and call tools using UnifAI Network
Unstructured - Set up and interact with your unstructured data processing workflows in Unstructured Platform
Upstash - Manage Redis databases and run Redis commands on Upstash with natural language.
Vectorize - Vectorize MCP server for advanced retrieval, Private Deep Research, Anything-to-Markdown file extraction and text chunking.
Verbwire - Deploy smart contracts, mint NFTs, manage IPFS storage, and more through the Verbwire API
Verodat - Interact with Verodat AI Ready Data platform
VeyraX - Single tool to control all 100+ API integrations, and UI components
WayStation - Universal MCP server to connect to popular productivity tools such as Notion, Monday, AirTable, and many more
WaveSpeed - WaveSpeed MCP server providing AI agents with image and video generation capabilities.
Xero - Interact with the accounting data in your business using our official MCP server
YugabyteDB - MCP Server to interact with your YugabyteDB database
Zapier - Connect your AI Agents to 8,000 apps instantly.
ZenML - Interact with your MLOps and LLMOps pipelines through your ZenML MCP server

🌎 Community Servers

A growing set of community-developed and maintained servers demonstrates various applications of MCP across different domains.

Note: Community servers are untested and should be used at your own risk. They are not affiliated with or endorsed by Anthropic.

1Panel - MCP server implementation that provides 1Panel interaction.
A2A - An MCP server that bridges the Model Context Protocol (MCP) with the Agent-to-Agent (A2A) protocol, enabling MCP-compatible AI assistants (like Claude) to seamlessly interact with A2A agents.
Ableton Live - an MCP server to control Ableton Live.
Ableton Live (by ahujasid) - Ableton integration allowing prompt enabled music creation.
Actor Critic Thinking - Actor-critic thinking for performance evaluation
Agentset - RAG for your knowledge base connected to Agentset.
AI Agent Marketplace Index - MCP server to search more than 5000+ AI agents and tools of various categories from AI Agent Marketplace Index and monitor traffic of AI Agents.
Airbnb - Provides tools to search Airbnb and get listing details.
Airflow - A MCP Server that connects to Apache Airflow using official python client.
Airtable - Read and write access to Airtable databases, with schema inspection.
Airtable - Airtable Model Context Protocol Server.
Algorand - A comprehensive MCP server for tooling interactions (40+) and resource accessibility (60+) plus many useful prompts for interacting with the Algorand blockchain.
AlphaVantage - MCP server for stock market data API AlphaVantage
Amadeus (by donghyun-chae) - An MCP server to access, explore, and interact with Amadeus Flight Offers Search API for retrieving detailed flight options, including airline, times, duration, and pricing data.
Amazon Ads - MCP Server that provides interaction capabilities with Amazon Advertising through MarketplaceAdPros/
Anki - An MCP server for interacting with your Anki decks and cards.
AntV Chart - A Model Context Protocol server for generating 15+ visual charts using AntV.
Any Chat Completions - Interact with any OpenAI SDK Compatible Chat Completions API like OpenAI, Perplexity, Groq, xAI and many more.
Apache Gravitino(incubating) - Allow LLMs to explore metadata of structured data and unstructured data with Gravitino, and perform data governance tasks including tagging/classification.
APIWeaver - An MCP server that dynamically creates MCP servers from web API configurations. This allows you to easily integrate any REST API, GraphQL endpoint, or web service into an MCP-compatible tool that can be used by AI assistants like Claude.
Apple Books - Interact with your library on Apple Books, manage your book collection, summarize highlights, notes, and much more.
Apple Calendar - An MCP server that allows you to interact with your MacOS Calendar through natural language, including features such as event creation, modification, schedule listing, finding free time slots etc.
Apple Script - MCP server that lets LLM run AppleScript code to to fully control anything on Mac, no setup needed.
Aranet4 - MCP Server to manage your Aranet4 CO2 sensor. Fetch data and store in a local SQLite. Ask questions about historical data.
ArangoDB - MCP Server that provides database interaction capabilities through ArangoDB.
Arduino - MCP Server that enables AI-powered robotics using Claude AI and Arduino (ESP32) for real-world automation and interaction with robots.
arXiv API - An MCP server that enables interacting with the arXiv API using natural language.
arxiv-latex-mcp - MCP server that fetches and processes arXiv LaTeX sources for precise interpretation of mathematical expressions in papers.
Atlassian - Interact with Atlassian Cloud products (Confluence and Jira) including searching/reading Confluence spaces/pages, accessing Jira issues, and project metadata.
Atlassian Server (by phuc-nt) - An MCP server that connects AI agents (Cline, Claude Desktop, Cursor, etc.) to Atlassian Jira & Confluence, enabling data queries and actions through the Model Context Protocol.
Attestable MCP - An MCP server running inside a trusted execution environment (TEE) via Gramine, showcasing remote attestation using RA-TLS. This allows an MCP client to verify the server before conencting.
Audius - Audius + AI = Atris. Interact with fans, stream music, tip your favorite artists, and more on Audius: all through Claude.
AWS - Perform operations on your AWS resources using an LLM.
AWS Athena - A MCP server for AWS Athena to run SQL queries on Glue Catalog.
AWS Cognito - A MCP server that connects to AWS Cognito for authentication and user management.
AWS Cost Explorer - Optimize your AWS spend (including Amazon Bedrock spend) with this MCP server by examining spend across regions, services, instance types and foundation models (demo video).
AWS Resources Operations - Run generated python code to securely query or modify any AWS resources supported by boto3.
AWS S3 - A sample MCP server for AWS S3 that flexibly fetches objects from S3 such as PDF documents.
Azure ADX - Query and analyze Azure Data Explorer databases.
Azure DevOps - An MCP server that provides a bridge to Azure DevOps services, enabling AI assistants to query and manage work items.
Azure MCP Hub - A curated list of all MCP servers and related resources for Azure developers by Arun Sekhar
Azure OpenAI DALL-E 3 MCP Server - A MCP server for Azure OpenAI DALL-E 3 service to generate image from text.
Azure Wiki Search - An MCP that enables AI to query the wiki hosted on Azure Devops Wiki.
Baidu AI Search - Web search with Baidu Cloud’s AI Search
BambooHR MCP - An MCP server that interfaces with the BambooHR APIs, providing access to employee data, time tracking, and HR management features.
Base Free USDC Transfer - Send USDC on Base for free using Claude AI! Built with Coinbase CDP.
Basic Memory - Local-first knowledge management system that builds a semantic graph from Markdown files, enabling persistent memory across conversations with LLMs.
BigQuery (by LucasHild) - This server enables LLMs to inspect database schemas and execute queries on BigQuery.
BigQuery (by ergut) - Server implementation for Google BigQuery integration that enables direct BigQuery database access and querying capabilities
Bilibili - This MCP server provides tools to fetch Bilibili user profiles, video metadata, search videos, and more.
Bing Web Search API (by hanchunglee) - Server implementation for Microsoft Bing Web Search API.
Bitable MCP (by lloydzhou) - MCP server provides access to Lark Bitable through the Model Context Protocol. It allows users to interact with Bitable tables using predefined tools.
Blender (by ahujasid) - Blender integration allowing prompt enabled 3D scene creation, modeling and manipulation.
BreakoutRoom - Agents accomplishing goals together in p2p rooms
browser-use (by co-browser) - browser-use MCP server with dockerized playwright + chromium + vnc. supports stdio & resumable http.
BrowserLoop - An MCP server for taking screenshots of web pages using Playwright. Supports high-quality capture with configurable formats, viewport sizes, cookie-based authentication, and both full page and element-specific screenshots.
Bsc-mcp The first MCP server that serves as the bridge between AI and BNB Chain, enabling AI agents to execute complex on-chain operations through seamless integration with the BNB Chain, including transfer, swap, launch, security check on any token and even more.
BVG MCP Server - (Unofficial) - Unofficial MCP server for Berliner Verkehrsbetriebe Api.
Calculator - This server enables LLMs to use calculator for precise numerical calculations.
Calendly - Calendly MCP server from agentr that provides support for managing events and scheduling via Calendly.
CCTV VMS MCP - A Model Context Protocol (MCP) server designed to connect to a CCTV recording program (VMS) to retrieve recorded and live video streams. It also provides tools to control the VMS software, such as showing live or playback dialogs for specific channels at specified times.
CFBD API - An MCP server for the College Football Data API.
ChatMCP – An Open Source Cross-platform GUI Desktop application compatible with Linux, macOS, and Windows, enabling seamless interaction with MCP servers across dynamically selectable LLMs, by AIQL
ChatSum - Query and Summarize chat messages with LLM. by mcpso
Chess.com - Access Chess.com player data, game records, and other public information through standardized MCP interfaces, allowing AI assistants to search and analyze chess information.
ChessPal Chess Engine (stockfish) - A Stockfish-powered chess engine exposed as an MCP server. Calculates best moves and supports both HTTP/SSE and stdio transports.
Chroma - Vector database server for semantic document search and metadata filtering, built on Chroma
Claude Thread Continuity - Persistent memory system enabling Claude Desktop conversations to resume with full context across sessions. Maintains conversation history, project states, and user preferences for seamless multi-session workflows.
ClaudePost - ClaudePost enables seamless email management for Gmail, offering secure features like email search, reading, and sending.
ClickUp - MCP server for ClickUp task management, supporting task creation, updates, bulk operations, and markdown descriptions.
Cloudinary - Cloudinary Model Context Protocol Server to upload media to Cloudinary and get back the media link and details.
Coda - Coda.io MCP server from agentr that provides support for reading and writing data to Coda docs and tables.
code-assistant - A coding assistant MCP server that allows to explore a code-base and make changes to code. Should be used with trusted repos only (insufficient protection against prompt injections).
code-executor - An MCP server that allows LLMs to execute Python code within a specified Conda environment.
code-sandbox-mcp - An MCP server to create secure code sandbox environment for executing code within Docker containers.
cognee-mcp - GraphRAG memory server with customizable ingestion, data processing and search
coin_api_mcp - Provides access to coinmarketcap cryptocurrency data.
CoinMarketCap - Implements the complete CoinMarketCap API for accessing cryptocurrency market data, exchange information, and other blockchain-related metrics.
commands - Run commands and scripts. Just like in a terminal.
Computer-Use - Remote MacOS Use - Open-source out-of-the-box alternative to OpenAI Operator, providing a full desktop experience and optimized for using remote macOS machines as autonomous AI agents.
consul-mcp - A consul MCP server for service management, health check and Key-Value Store
Contentful-mcp - Read, update, delete, publish content in your Contentful space(s) from this MCP Server.
context-portal - Context Portal (ConPort) is a memory bank database system that effectively builds a project-specific knowledge graph, capturing entities like decisions, progress, and architecture, along with their relationships. This serves as a powerful backend for Retrieval Augmented Generation (RAG), enabling AI assistants to access precise, up-to-date project information.
CreateveAI Nexus - Open-Source Bridge Between AI Agents and Enterprise Systems, with simple custom API plug-in capabilities (including close compatibility with ComfyUI nodes), support for Copilot Studio’s MCP agent integations, and support for Azure deployment in secure environments with secrets stored in Azure Key Vault, as well as straightforward on-premises deployment.
Creatify - MCP Server that exposes Creatify AI API capabilities for AI video generation, including avatar videos, URL-to-video conversion, text-to-speech, and AI-powered editing tools.
Cronlytic - Create CRUD operations for serverless cron jobs through Cronlytic MCP Server
crypto-feargreed-mcp - Providing real-time and historical Crypto Fear & Greed Index data.
crypto-indicators-mcp - An MCP server providing a range of cryptocurrency technical analysis indicators and strategies.
crypto-sentiment-mcp - An MCP server that delivers cryptocurrency sentiment analysis to AI agents.
cryptopanic-mcp-server - Providing latest cryptocurrency news to AI agents, powered by CryptoPanic.
Cursor MCP Installer - A tool to easily install and configure other MCP servers within Cursor IDE, with support for npm packages, local directories, and Git repositories.
Dappier - Connect LLMs to real-time, rights-cleared, proprietary data from trusted sources. Access specialized models for Real-Time Web Search, News, Sports, Financial Data, Crypto, and premium publisher content. Explore data models at marketplace.dappier.com.
Data Exploration - MCP server for autonomous data exploration on .csv-based datasets, providing intelligent insights with minimal effort. NOTE: Will execute arbitrary Python code on your machine, please use with caution!
Databricks - Allows LLMs to run SQL queries, list and get details of jobs executions in a Databricks account.
Databricks Genie - A server that connects to the Databricks Genie, allowing LLMs to ask natural language questions, run SQL queries, and interact with Databricks conversational agents.
Databricks Smart SQL - Leveraging Databricks Unity Catalog metadata, perform smart efficient SQL queries to solve Ad-hoc queries and explore data.
Datadog - Datadog MCP Server for application tracing, monitoring, dashboard, incidents queries built on official datadog api.
Dataset Viewer - Browse and analyze Hugging Face datasets with features like search, filtering, statistics, and data export
DataWorks - A Model Context Protocol (MCP) server that provides tools for AI, allowing it to interact with the DataWorks Open API through a standardized interface. This implementation is based on the Alibaba Cloud Open API and enables AI agents to perform cloud resources operations seamlessly.
DaVinci Resolve - MCP server integration for DaVinci Resolve providing powerful tools for video editing, color grading, media management, and project control.
DBHub - Universal database MCP server connecting to MySQL, PostgreSQL, SQLite, DuckDB and etc.
Deebo – Agentic debugging MCP server that helps AI coding agents delegate and fix hard bugs through isolated multi-agent hypothesis testing.
Deep Research - Lightweight MCP server offering Grok/OpenAI/Gemini/Perplexity-style automated deep research exploration and structured reporting.
DeepSeek MCP Server - Model Context Protocol server integrating DeepSeek’s advanced language models, in addition to other useful API endpoints
deepseek-thinker-mcp - A MCP (Model Context Protocol) provider Deepseek reasoning content to MCP-enabled AI Clients, like Claude Desktop. Supports access to Deepseek’s thought processes from the Deepseek API service or from a local Ollama server.
Deepseek_R1 - A Model Context Protocol (MCP) server implementation connecting Claude Desktop with DeepSeek’s language models (R1/V3)
Descope - An MCP server to integrate with Descope to search audit logs, manage users, and more.
DesktopCommander - Let AI edit and manage files on your computer, run terminal commands, and connect to remote servers via SSH - all powered by one of the most popular local MCP servers.
DevDb - An MCP server that runs right inside the IDE, for connecting to MySQL, Postgres, SQLite, and MSSQL databases.
Dicom - An MCP server to query and retrieve medical images and for parsing and reading dicom-encapsulated documents (pdf etc.).
Dify - A simple implementation of an MCP server for dify workflows.
Discogs - A MCP server that connects to the Discogs API for interacting with your music collection.
Discord - A MCP server to connect to Discord guilds through a bot and read and write messages in channels
Discord - A MCP server, which connects to Discord through a bot, and provides comprehensive integration with Discord.
Discord - For Discord API integration by Klavis AI
Discourse - A MCP server to search Discourse posts on a Discourse forum.
Docker - Integrate with Docker to manage containers, images, volumes, and networks.
Docs - Enable documentation access for the AI agent, supporting llms.txt and other remote or local files.
Dodo Payments - Enables AI agents to securely perform payment operations via a lightweight, serverless-compatible interface to the Dodo Payments API.
DPLP - Searches the DBLP computer science bibliography database.
Drupal - Server for interacting with Drupal using STDIO transport layer.
dune-analytics-mcp - A mcp server that bridges Dune Analytics data to AI agents.
DynamoDB-Toolbox - Leverages your Schemas and Access Patterns to interact with your DynamoDB Database using natural language.
eBook-mcp - A lightweight MCP server that allows LLMs to read and interact with your personal PDF and EPUB ebooks. Ideal for building AI reading assistants or chat-based ebook interfaces.
EdgeOne Pages MCP - An MCP service for deploying HTML content to EdgeOne Pages and obtaining a publicly accessible URL.
Edwin - MCP server for edwin SDK - enabling AI agents to interact with DeFi protocols across EVM, Solana and other blockchains.
eechat - An open-source, cross-platform desktop application that seamlessly connects with MCP servers, across Linux, macOS, and Windows.
Elasticsearch - MCP server implementation that provides Elasticsearch interaction.
ElevenLabs - A server that integrates with ElevenLabs text-to-speech API capable of generating full voiceovers with multiple voices.
Email - This server enables users to send emails through various email providers, including Gmail, Outlook, Yahoo, Sina, Sohu, 126, 163, and QQ Mail. It also supports attaching files from specified directories, making it easy to upload attachments along with the email content.
Email SMTP - A simple MCP server that lets your AI agent send emails and attach files through SMTP.
Enhance Prompt - An MCP service for enhance you prompt.
Ergo Blockchain MCP -An MCP server to integrate Ergo Blockchain Node and Explorer APIs for checking address balances, analyzing transactions, viewing transaction history, performing forensic analysis of addresses, searching for tokens, and monitoring network status.
Eunomia - Extension of the Eunomia framework that connects Eunomia instruments with MCP servers
Everything Search - Fast file searching capabilities across Windows (using Everything SDK), macOS (using mdfind command), and Linux (using locate/plocate command).
EVM MCP Server - Comprehensive blockchain services for 30+ EVM networks, supporting native tokens, ERC20, NFTs, smart contracts, transactions, and ENS resolution.
Excel - Excel manipulation including data reading/writing, worksheet management, formatting, charts, and pivot table.
Fabric MCP - Microsoft Fabric MCP server to accelerate working in your Fabric Tenant with the help of your favorite LLM models.
fabric-mcp-server - The fabric-mcp-server is an MCP server that integrates Fabric patterns with Cline, exposing them as tools for AI-driven task execution and enhancing Cline’s capabilities.
Facebook Ads - MCP server acting as an interface to the Facebook Ads, enabling programmatic access to Facebook Ads data and management features.
Fantasy PL - Give your coding agent direct access to up-to date Fantasy Premier League data
fastn.ai – Unified API MCP Server - A remote, dynamic MCP server with a unified API that connects to 1,000+ tools, actions, and workflows, featuring built-in authentication and monitoring.
FDIC BankFind MCP Server - (Unofficial) - The is a MCPserver that brings the power of FDIC BankFind APIs straight to your AI tools and workflows. Structured U.S. banking data, delivered with maximum vibes. 😎📊
Federal Reserve Economic Data (FRED) (by Stefano Amorelli) - Community developed MCP server to interact with the Federal Reserve Economic Data.
Fetch - A server that flexibly fetches HTML, JSON, Markdown, or plaintext.
Figma - Give your coding agent direct access to Figma file data, helping it one-shot design implementation.
Fingertip - MCP server for Fingertip.com to search and create new sites.
Firebase - Server to interact with Firebase services including Firebase Authentication, Firestore, and Firebase Storage.
FireCrawl - Advanced web scraping with JavaScript rendering, PDF support, and smart rate limiting
FitBit MCP Server - An MCP server that connects to FitBit API using a token obtained from OAuth flow.
FlightRadar24 - A Claude Desktop MCP server that helps you track flights in real-time using Flightradar24 data.
Flyworks Avatar - Fast and free zeroshot lipsync MCP server.
Foursquare - Enable your agent to recommend places around the world with the Foursquare Places API
freqtrade-mcp - An MCP server that integrates with the Freqtrade cryptocurrency trading bot.
GDB - A GDB/MI protocol server based on the MCP protocol, providing remote application debugging capabilities with AI assistants.
Ghost - A Model Context Protocol (MCP) server for interacting with Ghost CMS through LLM interfaces like Claude.
Git - Allows LLM to interact with a local git repository, incl. optional push support.
Github Actions - A Model Context Protocol (MCP) server for interacting with Github Actions.
GitHub Enterprise MCP - A Model Context Protocol (MCP) server for interacting with GitHub Enterprise.
GitMCP - gitmcp.io is a generic remote MCP server to connect to ANY GitHub repository or project documentation effortlessly
Glean - A server that uses Glean API to search and chat.
Gmail - A Model Context Protocol (MCP) server for Gmail integration in Claude Desktop with auto authentication support.
Gmail Headless - Remote hostable MCP server that can get and send Gmail messages without local credential or file system setup.
Gnuradio - An MCP server for GNU Radio that enables LLMs to autonomously create and modify RF .grc flowcharts.
Goal Story - a Goal Tracker and Visualization Tool for personal and professional development.
GOAT - Run more than +200 onchain actions on any blockchain including Ethereum, Solana and Base.
Godot - A MCP server providing comprehensive Godot engine integration for project editing, debugging, and scene management.
Golang Filesystem Server - Secure file operations with configurable access controls built with Go!
Goodnews - A simple MCP server that delivers curated positive and uplifting news stories.
Google Analytics - Google Analytics MCP Server to bring data across 200+ dimensions & metrics for LLMs to analyse.
Google Calendar - Integration with Google Calendar to check schedules, find time, and add/delete events
Google Calendar - Google Calendar MCP Server for managing Google calendar events. Also supports searching for events by attributes like title and location.
Google Custom Search - Provides Google Search results via the Google Custom Search API
Google Sheets - Access and editing data to your Google Sheets.
Google Sheets - A MCP Server written in TypeScript to access and edit data in your Google Sheets.
Google Tasks - Google Tasks API Model Context Protocol Server.
Google Vertex AI Search - Provides Google Vertex AI Search results by grounding a Gemini model with your own private data
Google Workspace - Comprehensive Google Workspace MCP with full support for Calendar, Drive, Gmail, and Docs using Streamable HTTP or SSE transport.
GraphQL - Comprehensive GraphQL API integration that automatically exposes each GraphQL query as a separate tool.
GraphQL Schema - Allow LLMs to explore large GraphQL schemas without bloating the context.
Hashing MCP Server - MCP Server with cryptographic hashing functions e.g. SHA256, MD5, etc.
HDW LinkedIn - Access to profile data and management of user account with HorizonDataWave.ai.
Helm Chart CLI - Helm MCP provides a bridge between AI assistants and the Helm package manager for Kubernetes. It allows AI assistants to interact with Helm through natural language requests, executing commands like installing charts, managing repositories, and more.
Heurist Mesh Agent - Access specialized web3 AI agents for blockchain analysis, smart contract security, token metrics, and blockchain interactions through the Heurist Mesh network.
Holaspirit - Interact with Holaspirit.
Home Assistant - Interact with Home Assistant including viewing and controlling lights, switches, sensors, and all other Home Assistant entities.
Home Assistant - Docker-ready MCP server for Home Assistant with entity management, domain summaries, automation support, and guided conversations. Includes pre-built container images for easy installation.
HubSpot - HubSpot CRM integration for managing contacts and companies. Create and retrieve CRM data directly through Claude chat.
HuggingFace Spaces - Server for using HuggingFace Spaces, supporting Open Source Image, Audio, Text Models and more. Claude Desktop mode for easy integration.
Human-In-the-Loop - A powerful MCP Server that enables AI assistants like Claude to interact with humans through intuitive GUI dialogs. This server bridges the gap between automated AI processes and human decision-making by providing real-time user input tools, choices, confirmations, and feedback mechanisms.
Human-use - Instant human feedback through an MCP, have your AI interact with humans around the world. Powered by Rapidata
Hyperliquid - An MCP server implementation that integrates the Hyperliquid SDK for exchange data.
hyprmcp (by Stefano Amorelli) - Lightweight MCP server for hyprland.
iFlytek SparkAgent Platform - This is a simple example of using MCP Server to invoke the task chain of the iFlytek SparkAgent Platform.
iFlytek Workflow - Connect to iFlytek Workflow via the MCP server and run your own Agent.
Image Generation - This MCP server provides image generation capabilities using the Replicate Flux model.
iMCP - A macOS app that provides an MCP server for your iMessage, Reminders, and other Apple services.
InfluxDB - Run queries against InfluxDB OSS API v2.
Inoyu - Interact with an Apache Unomi CDP customer data platform to retrieve and update customer profiles
interactive-mcp - Enables interactive LLM workflows by adding local user prompts and chat capabilities directly into the MCP loop.
Intercom - An MCP-compliant server for retrieving customer support tickets from Intercom. This tool enables AI assistants like Claude Desktop and Cline to access and analyze your Intercom support tickets.
iOS Simulator - A Model Context Protocol (MCP) server that enables LLMs to interact with iOS simulators (iPhone, iPad, etc.) through natural language commands.
iTerm MCP - Integration with iTerm2 terminal emulator for macOS, enabling LLMs to execute and monitor terminal commands.
iTerm MCP Server - A Model Context Protocol (MCP) server implementation for iTerm2 terminal integration. Able to manage multiple iTerm Sessions.
Java Decompiler - Decompile Java bytecode into readable source code from .class files, package names, or JAR archives using CFR decompiler
JavaFX - Make drawings using a JavaFX canvas
JavaFX - Make drawings using a JavaFX canvas
JDBC - Connect to any JDBC-compatible database and query, insert, update, delete, and more. Supports MySQL, PostgreSQL, Oracle, SQL Server, sqllite and more.
JMeter - Run load testing using Apache JMeter via MCP-compliant tools.
Job Searcher - A FastMCP server that provides tools for retrieving and filtering job listings based on time period, keywords, and remote work preferences.
jobswithgpt - Job search MCP using jobswithgpt which indexes 500K+ public job listings and refreshed continously.
JSON - JSON handling and processing server with advanced query capabilities using JSONPath syntax and support for array, string, numeric, and date operations.
JSON2Video MCP - A Model Context Protocol (MCP) server implementation for programmatically generating videos using the json2video API. This server exposes powerful video generation and status-checking tools for use with LLMs, agents, or any MCP-compatible client.
jupiter-mcp - An MCP server for executing token swaps on the Solana blockchain using Jupiter’s new Ultra API.
Jupyter Notebook - connects Jupyter Notebook to Claude AI, allowing Claude to directly interact with and control Jupyter Notebooks. This integration enables AI-assisted code execution, data analysis, visualization, and more.
k8s-multicluster-mcp - An MCP server for interact with multiple Kubernetes clusters simultaneously using multiple kubeconfig files.
Keycloak MCP - This MCP server enables natural language interaction with Keycloak for user and realm management including creating, deleting, and listing users and realms.
Kibana MCP (by TocharianOU) - A community-maintained MCP server implementation that allows any MCP-compatible client to access and manage Kibana instances through natural language or programmatic requests.
Kibela (by kiwamizamurai) - Interact with Kibela API.
KiCad MCP - MCP server for KiCad on Mac, Windows, and Linux.
kintone - Manage records and apps in kintone through LLM tools.
Kokoro TTS - Use Kokoro text to speech to convert text to MP3s with optional autoupload to S3.
Kong Konnect - A Model Context Protocol (MCP) server for interacting with Kong Konnect APIs, allowing AI assistants to query and analyze Kong Gateway configurations, traffic, and analytics.
Kubernetes - Connect to Kubernetes cluster and manage pods, deployments, and services.
Kubernetes and OpenShift - A powerful Kubernetes MCP server with additional support for OpenShift. Besides providing CRUD operations for any Kubernetes resource, this server provides specialized tools to interact with your cluster.
KubeSphere - The KubeSphere MCP Server is a Model Context Protocol(MCP) server that provides integration with KubeSphere APIs, enabling to get resources from KubeSphere. Divided into four tools modules: Workspace Management, Cluster Management, User and Roles, Extensions Center.
Langflow-DOC-QA-SERVER - A Model Context Protocol server for document Q&A powered by Langflow. It demonstrates core MCP concepts by providing a simple interface to query documents through a Langflow backend.
Lark(Feishu) - A Model Context Protocol(MCP) server for Lark(Feishu) sheet, message, doc and etc.
lean-lsp-mcp - Interact with the Lean theorem prover via the Language Server Protocol.
Lightdash - Interact with Lightdash, a BI tool.
LINE (by amornpan) - Implementation for LINE Bot integration that enables Language Models to read and analyze LINE conversations through a standardized interface. Features asynchronous operation, comprehensive logging, webhook event handling, and support for various message types.
Linear - Interact with Linear project management system.
Linear - Allows LLM to interact with Linear’s API for project management, including searching, creating, and updating issues.
Linear (Go) - Allows LLM to interact with Linear’s API via a single static binary.
Linear MCP - Full blown implementation of the Linear SDK to support comprehensive Linear management of projects, initiatives, issues, users, teams and states.
LlamaCloud (by marcusschiesser) - Integrate the data stored in a managed index on LlamaCloud
lldb-mcp - A Model Context Protocol server for LLDB that provides LLM-driven debugging.
llm-context - Provides a repo-packing MCP tool with configurable profiles that specify file inclusion/exclusion patterns and optional prompts.
Loki - Golang based MCP Server to query logs from Grafana Loki.
LottieFiles - Searching and retrieving Lottie animations from LottieFiles
lsp-mcp - Interact with Language Servers usint the Language Server Protocol to provide additional context information via hover, code actions and completions.
Lspace - Turn scattered ChatGPT/Claude/Cursor conversations into persistent, searchable knowledge.
lucene-mcp-server - spring boot server using Lucene for fast document search and management.
mac-messages-mcp - An MCP server that securely interfaces with your iMessage database via the Model Context Protocol (MCP), allowing LLMs to query and analyze iMessage conversations. It includes robust phone number validation, attachment processing, contact management, group chat handling, and full support for sending and receiving messages.
Maestro MCP - An MCP server for interacting with Bitcoin via the Maestro RPC API.
MalwareBazaar_MCP (by Kevin Thomas) - An AI-driven MCP server that autonomously interfaces with MalwareBazaar, delivering real-time threat intel and sample metadata for authorized cybersecurity research workflows.
MariaDB - MariaDB database integration with configurable access controls in Python.
Markdown2doc - Convert between various file formats using Pandoc
Markdownify - MCP to convert almost anything to Markdown (PPTX, HTML, PDF, Youtube Transcripts and more)
Markitdown - Convert files to Markdown
MasterGo - The server designed to connect MasterGo design tools with AI models. It enables AI models to directly retrieve DSL data from MasterGo design files.
Matlab-MCP-Tools - An MCP to write and execute MATLAB scripts, maintain workspace context between MCP calls, visualize plots, and perform section-by-section analysis of MATLAB code with full access to MATLAB’s computational capabilities.
Maton - Connect to your SaaS tools like HubSpot, Salesforce, and more.
MCP Compass - Suggest the right MCP server for your needs
MCP Create - A dynamic MCP server management service that creates, runs, and manages Model Context Protocol servers on-the-fly.
MCP Installer - This server is a server that installs other MCP servers for you.
MCP Proxy Server - An MCP proxy server that aggregates and serves multiple MCP resource servers through a single HTTP server.
MCP Server Creator - A powerful Model Context Protocol (MCP) server that creates other MCP servers! This meta-server provides tools for dynamically generating FastMCP server configurations and Python code.
MCP STDIO to Streamable HTTP Adapter - Connect to Streamable HTTP MCP Servers even if the MCP Client only supports STDIO.
mcp-containerd - The containerd MCP implemented by Rust supports the operation of the CRI interface.
MCP-Database-Server - Fastest way to interact with your Database such as SQL Server, SQLite and PostgreSQL
mcp-grep - Python-based MCP server that brings grep functionality to LLMs. Supports common grep features including pattern searching, case-insensitive matching, context lines, and recursive directory searches.
mcp-k8s-go - Golang-based Kubernetes server for MCP to browse pods and their logs, events, namespaces and more. Built to be extensible.
mcp-local-rag - “primitive” RAG-like web search model context protocol (MCP) server that runs locally using Google’s MediaPipe Text Embedder and DuckDuckGo Search.
mcp-meme-sticky - Make memes or stickers using MCP server for WhatsApp or Telegram.
MCP-NixOS - A Model Context Protocol server that provides AI assistants with accurate, real-time information about NixOS packages, system options, Home Manager settings, and nix-darwin macOS configurations.
mcp-open-library - A Model Context Protocol (MCP) server for the Open Library API that enables AI assistants to search for book and author information.
mcp-proxy - Connect to MCP servers that run on SSE transport, or expose stdio servers as an SSE server.
mcp-salesforce - MCP server with basic demonstration of interactions with your Salesforce instance
mcp-sanctions - Screen individuals and organizations against global sanctions lists (OFAC, SDN, UN, etc). Query by prompt or document upload.
mcp-server-leetcode - Practice and retrieve problems from LeetCode. Automate problem retrieval, solutions, and insights for coding practice and competitions.
mcp-vision - A MCP server exposing HuggingFace computer vision models such as zero-shot object detection as tools, enhancing the vision capabilities of large language or vision-language models.
mcp-weather - Accurate weather forecasts via the AccuWeather API (free tier available).
mcp_weather - Get weather information from https://api.open-meteo.com API.
MCPIgnore Filesytem - A Data Security First filesystem MCP server that implements .mcpignore to prevent MCP clients from accessing sensitive data.
MediaWiki MCP adapter - A custom Model Context Protocol adapter for MediaWiki and WikiBase APIs
mem0-mcp - A Model Context Protocol server for Mem0, which helps with managing coding preferences.
Membase - Save and query your agent memory in distributed way by Membase.
MetaTrader MCP - Enable AI LLMs to execute trades using MetaTrader 5 platform.
Metricool MCP - A Model Context Protocol server that integrates with Metricool’s social media analytics platform to retrieve performance metrics and schedule content across networks like Instagram, Facebook, Twitter, LinkedIn, TikTok and YouTube.
Microsoft 365 - (by Merill) A Model Context Protocol (MCP) server for Microsoft 365. Includes support for all services including Teams, SharePoint, Exchange, OneDrive, Entra, Intune and more. See Lokka for more details.
Microsoft 365 - MCP server that connects to Microsoft Office and the whole Microsoft 365 suite using Graph API (including Outlook/mail, files, Excel, calendar)
Microsoft Teams - MCP server that integrates Microsoft Teams messaging (read, post, mention, list members and threads)
Mifos X - A MCP server for the Mifos X Open Source Banking useful for managing clients, loans, savings, shares, financial transactions and generating financial reports.
Mikrotik - Mikrotik MCP server which cover networking operations (IP, DHCP, Firewall, etc)
Mindmap (by YuChenSSR) - A server that generates mindmaps from input containing markdown code.
Minima - MCP server for RAG on local files
Mobile MCP (by Mobile Next) - MCP server for Mobile(iOS/Android) automation, app scraping and development using physical devices or simulators/emulators.
Monday.com - MCP Server to interact with Monday.com boards and items.
MongoDB - A Model Context Protocol Server for MongoDB.
MongoDB & Mongoose - MongoDB MCP Server with Mongoose Schema and Validation.
MongoDB Lens - Full Featured MCP Server for MongoDB Databases.
Monzo - Access and manage your Monzo bank accounts through natural language, including balance checking, pot management, transaction listing, and transaction annotation across multiple account types (personal, joint, flex).
Morningstar - MCP Server to interact with Morningstar Research, Editorial and Datapoints
MSSQL - MSSQL database integration with configurable access controls and schema inspection
MSSQL (by jexin) - MCP Server for MSSQL database in Python
MSSQL-MCP (by daobataotie) - MSSQL MCP that refer to the official website’s SQLite MCP for modifications to adapt to MSSQL
MSSQL-Python (by amornpan) - A read-only Python implementation for MSSQL database access with enhanced security features, configurable access controls, and schema inspection capabilities. Focuses on safe database interaction through Python ecosystem.
Multi-Model Advisor - A Model Context Protocol (MCP) server that orchestrates queries across multiple Ollama models, synthesizing their insights to deliver a comprehensive and multifaceted AI perspective on any given query.
Multicluster-MCP-Sever - The gateway for GenAI systems to interact with multiple Kubernetes clusters.
MySQL (by benborla) - MySQL database integration in NodeJS with configurable access controls and schema inspection
MySQL (by DesignComputer) - MySQL database integration in Python with configurable access controls and schema inspection
n8n - This MCP server provides tools and resources for AI assistants to manage n8n workflows and executions, including listing, creating, updating, and deleting workflows, as well as monitoring their execution status.
Nacos MCP Router - This MCP(Model Context Protocol) Server provides tools to search, install, proxy other MCP servers.
NASA (by ProgramComputer) - Access to a unified gateway of NASA’s data sources including but not limited to APOD, NEO, EPIC, GIBS.
Nasdaq Data Link (by stefanoamorelli) - An MCP server to access, explore, and interact with Nasdaq Data Link’s extensive and valuable financial and economic datasets.
National Parks - The server provides latest information of park details, alerts, visitor centers, campgrounds, hiking trails, and events for U.S. National Parks.
NAVER (by pfldy2850) - This MCP server provides tools to interact with various Naver services, such as searching blogs, news, books, and more.
NBA - This MCP server provides tools to fetch recent and historical NBA games including basic and advanced statistics.
Neo4j - A community built server that interacts with Neo4j Graph Database.
Neovim - An MCP Server for your Neovim session.
Netbird - List and analyze Netbird network peers, groups, policies, and more.
NocoDB - Read and write access to NocoDB database.
nomad-mcp - A server that provides a set of tools for managing Nomad clusters through the MCP.
Notion (by suekou) - Interact with Notion API.
Notion (by v-3) - Notion MCP integration. Search, Read, Update, and Create pages through Claude chat.
NS Travel Information - Access Dutch Railways (NS) real-time train travel information and disruptions through the official NS API.
ntfy-mcp (by teddyzxcv) - The MCP server that keeps you informed by sending the notification on phone using ntfy
ntfy-me-mcp (by gitmotion) - An ntfy MCP server for sending/fetching ntfy notifications to your self-hosted ntfy server from AI Agents 📤 (supports secure token auth & more - use with npx or docker!)
oatpp-mcp - C++ MCP integration for Oat++. Use Oat++ to build MCP servers.
Obsidian Markdown Notes - Read and search through your Obsidian vault or any directory containing Markdown notes
obsidian-mcp - (by Steven Stavrakis) An MCP server for Obsidian.md with tools for searching, reading, writing, and organizing notes.
OceanBase - (by yuanoOo) A Model Context Protocol (MCP) server that enables secure interaction with OceanBase databases.
Office-PowerPoint-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft PowerPoint documents.
Office-Visio-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft Visio documents.
Office-Word-MCP-Server - A Model Context Protocol (MCP) server for creating, reading, and manipulating Microsoft Word documents.
Okta - Interact with Okta API.
OneNote - (by Rajesh Vijay) An MCP server that connects to Microsoft OneNote using the Microsoft Graph API. Reading notebooks, sections, and pages from OneNote,Creating new notebooks, sections, and pages in OneNote.
Open Strategy Partners Marketing Tools - Content editing codes, value map, and positioning tools for product marketing.
OpenAI WebSearch MCP - This is a Python-based MCP server that provides OpenAI web_search build-in tool.
OpenAPI - Interact with OpenAPI APIs.
OpenAPI AnyApi - Interact with large OpenAPI docs using built-in semantic search for endpoints. Allows for customizing the MCP server prefix.
OpenAPI Schema - Allow LLMs to explore large OpenAPI schemas without bloating the context.
OpenAPI Schema Explorer - Token-efficient access to local or remote OpenAPI/Swagger specs via MCP Resources.
OpenCTI - Interact with OpenCTI platform to retrieve threat intelligence data including reports, indicators, malware and threat actors.
OpenCV - A MCP server providing OpenCV computer vision capabilities. This allows AI assistants and language models to access powerful computer vision tools.
OpenDota - Interact with OpenDota API to retrieve Dota 2 match data, player statistics, and more.
OpenRPC - Interact with and discover JSON-RPC APIs via OpenRPC.
OpenWeather - Interact with the free openweathermap API to get the current and forecast weather for a location.
Oura Ring (by Rajesh Vijay) - MCP Server to access and analyze your Oura Ring data. It provides a structured way to fetch and understand your health metrics.
Outline - MCP Server to interact with Outline knowledge base to search, read, create, and manage documents and their content, access collections, add comments, and manage document backlinks.
pancakeswap-poolspy-mcp - An MCP server that tracks newly created liquidity pools on Pancake Swap.
Pandoc - MCP server for seamless document format conversion using Pandoc, supporting Markdown, HTML, PDF, DOCX (.docx), csv and more.
Paradex MCP - MCP native server for interacting with Paradex platform, including fully features trading.
Peacock for VS Code - MCP Server for the Peacock extension for VS Code, coloring your world, one Code editor at a time. The main goal of the project is to show how an MCP server can be used to interact with APIs.
Phone MCP - 📱 A powerful plugin that lets you control your Android phone. Enables AI agents to perform complex tasks like automatically playing music based on weather or making calls and sending texts.
PIF - A Personal Intelligence Framework (PIF), providing tools for file operations, structured reasoning, and journal-based documentation to support continuity and evolving human-AI collaboration across sessions.
Pinecone - MCP server for searching and uploading records to Pinecone. Allows for simple RAG features, leveraging Pinecone’s Inference API.
Pinner MCP - A MCP server for pinning GitHub Actions and container base images to their immutable SHA hashes to prevent supply chain attacks.
Placid.app - Generate image and video creatives using Placid.app templates
Plane - This MCP Server will help you to manage projects and issues through Plane’s API
Playwright - This MCP Server will help you run browser automation and webscraping using Playwright
Postman - MCP server for running Postman Collections locally via Newman. Allows for simple execution of Postman Server and returns the results of whether the collection passed all the tests.
Prefect - MCP Server for workflow orchestration and ELT/ETL with Prefect Server, and Prefect Cloud [https://www.prefect.io/] using the prefect python client.
Productboard - Integrate the Productboard API into agentic workflows via MCP.
Prometheus - Query and analyze Prometheus - open-source monitoring system.
PubChem - extract drug information from pubchem API.
Pulumi - MCP Server to Interact with Pulumi API, creates and lists Stacks
Puppeteer vision - Use Puppeteer to browse a webpage and return a high quality Markdown. Use AI vision capabilities to handle cookies, captchas, and other interactive elements automatically.
Pushover - Send instant notifications to your devices using Pushover.net
pydantic/pydantic-ai/mcp-run-python - Run Python code in a secure sandbox via MCP tool calls, powered by Deno and Pyodide
QGIS - connects QGIS to Claude AI through the MCP. This integration enables prompt-assisted project creation, layer loading, code execution, and more.
Qiniu MCP Server - The Model Context Protocol (MCP) Server built on Qiniu Cloud products supports users in accessing Qiniu Cloud Storage, intelligent multimedia services, and more through this MCP Server within the context of AI large model clients.
Quarkus - MCP servers for the Quarkus Java framework.
QuickChart - A Model Context Protocol server for generating charts using QuickChart.io
Qwen_Max - A Model Context Protocol (MCP) server implementation for the Qwen models.
RabbitMQ - The MCP server that interacts with RabbitMQ to publish and consume messages.
RAG Local - This MCP server for storing and retrieving text passages locally based on their semantic meaning.
RAG Web Browser An MCP server for Apify’s open-source RAG Web Browser Actor to perform web searches, scrape URLs, and return content in Markdown.
Raindrop.io - An integration that allows LLMs to interact with Raindrop.io bookmarks using the Model Context Protocol (MCP).
Reaper - Interact with your Reaper (Digital Audio Workstation) projects.
Redis - Redis database operations and caching microservice server with support for key-value operations, expiration management, and pattern-based key listing.
Redis MCP server to interact with Redis Server, AWS Memory DB, etc for caching or other use-cases where in-memory and key-value based storage is appropriate
RedNote MCP - MCP server for accessing RedNote(XiaoHongShu, xhs) content
Reed Jobs - Search and retrieve job listings from Reed.co.uk.
Rememberizer AI - An MCP server designed for interacting with the Rememberizer data source, facilitating enhanced knowledge retrieval.
Replicate - Search, run and manage machine learning models on Replicate through a simple tool-based interface. Browse models, create predictions, track their status, and handle generated images.
Resend - Send email using Resend services
Rijksmuseum - Interface with the Rijksmuseum API to search artworks, retrieve artwork details, access image tiles, and explore user collections.
Riot Games - MCP server for League of Legends – fetch player info, ranks, champion stats, and match history via Riot API.
Rquest - An MCP server providing realistic browser-like HTTP request capabilities with accurate TLS/JA3/JA4 fingerprints for bypassing anti-bot measures.
Rust MCP Filesystem - Fast, asynchronous MCP server for efficient handling of various filesystem operations built with the power of Rust.
Salesforce MCP - Salesforce MCP server. Supports cloud version Salesforce-mcp.com and allows both data & metadata functions.
Salesforce MCP - Interact with Salesforce Data and Metadata
Salesforce MCP Server - Comprehensive Salesforce integration with tools for querying records, executing Apex, managing fields/objects, and handling debug logs
Scholarly - A MCP server to search for scholarly and academic articles.
scrapling-fetch - Access text content from bot-protected websites. Fetches HTML/markdown from sites with anti-automation measures using Scrapling.
SearXNG - A Model Context Protocol Server for SearXNG
SearXNG - A MCP server provide web searching via SearXNG & retrieve url as makrdown.
SearXNG Public - A Model Context Protocol Server for retrieving data from public SearXNG instances, with fallback support
SEC EDGAR - (by Stefano Amorelli) A community Model Context Protocol Server to access financial filings and data through the U.S. Securities and Exchange Commission (SEC) Electronic Data Gathering, Analysis, and Retrieval (EDGAR) database
Serper - An MCP server that performs Google searches using Serper.
ServiceNow - A MCP server to interact with a ServiceNow instance
ShaderToy - This MCP server lets LLMs to interact with the ShaderToy API, allowing LLMs to learn from compute shaders examples and enabling them to create complex GLSL shaders that they are previously not capable of.
Shodan MCP - MCP server to interact with Shodan
Shopify - MCP to interact with Shopify API including order, product, customers and so on.
Simple Loki MCP - A simple MCP server to query Loki logs using logcli.
Siri Shortcuts - MCP to interact with Siri Shortcuts on macOS. Exposes all Shortcuts as MCP tools.
Skyvern - MCP to let Claude / Windsurf / Cursor / your LLM control the browser
Slack - The most powerful MCP server for Slack Workspaces. This integration supports both Stdio and SSE transports, proxy settings and does not require any permissions or bots being created or approved by Workspace admins 😏.
Slidespeak - Create PowerPoint presentations using the Slidespeak API.
Smartlead - MCP to connect to Smartlead. Additional, tooling, functionality, and connection to workflow automation platforms also available.
Snowflake - This MCP server enables LLMs to interact with Snowflake databases, allowing for secure and controlled data operations.
SoccerDataAPI - This MCP server provides real-time football match data based on the SoccerDataAPI.
Solana Agent Kit - This MCP server enables LLMs to interact with the Solana blockchain with help of Solana Agent Kit by SendAI, allowing for 40+ protcool actions and growing
Solr MCP - This MCP server offers a basic functionality to perform a search on Solr servers.
Solver - Solves constraint satisfaction and optimization problems .
Splunk - Golang MCP server for Splunk (lists saved searches, alerts, indexes, macros…). Supports SSE and STDIO.
Spotify - This MCP allows an LLM to play and use Spotify.
Spring Initializr - This MCP allows an LLM to create Spring Boot projects with custom configurations. Instead of manually visiting start.spring.io, you can now ask your AI assistant to generate projects with specific dependencies, Java versions, and project structures.
SSH - Agent for managing and controlling SSH connections.
SSH - An MCP server that can execute SSH commands remotely, upload files, download files, and so on.
Standard Korean Dictionary - Search the dictionary using API
Star Wars -MCP Server for the SWAPI Star Wars API. The main goal of the project is to show how an MCP server can be used to interact with APIs.
Starknet MCP Server - A comprehensive MCP server for interacting with the Starknet blockchain, providing tools for querying blockchain data, resolving StarknetIDs, and performing token transfers.
Starwind UI - This MCP provides relevant commands, documentation, and other information to allow LLMs to take full advantage of Starwind UI’s open source Astro components.
Stitch AI - Knowledge management system for AI agents with memory space creation and retrieval capabilities.
Strava - Connect to the Strava API to access activity data, athlete profiles, segments, and routes, enabling fitness tracking and analysis with Claude.
Stripe - This MCP allows integration with Stripe for handling payments, customers, and refunds.
Substack/Medium - Connect Claude to your Substack/Medium writing, enabling semantic search and analysis of your published content.
System Health - The MCP (Multi-Channel Protocol) System Health Monitoring is a robust, real-time monitoring solution designed to provide comprehensive health metrics and alerts for remote Linux servers.
Talk To Figma - This MCP server enables LLMs to interact with Figma, allowing them to read and modify designs programmatically.
Tavily search - An MCP server for Tavily’s search & news API, with explicit site inclusions/exclusions
TeamRetro - This MCP server allows LLMs to interact with TeamRetro, allowing LLMs to manage user, team, team member, retrospective, health check, action, agreement and fetch the reports.
Telegram - An MCP server that provides paginated chat reading, message retrieval, and message sending capabilities for Telegram through Telethon integration.
Telegram-Client - A Telegram API bridge that manages user data, dialogs, messages, drafts, read status, and more for seamless interactions.
Tempo - An MCP server to query traces/spans from Grafana Tempo.
Teradata - his MCP server enables LLMs to interact with Teradata databases. This MCP Server support tools and prompts for multi task data analytics
Terminal-Control - A MCP server that enables secure terminal command execution, directory navigation, and file system operations through a standardized interface.
Terraform-Cloud - An MCP server that integrates AI assistants with the Terraform Cloud API, allowing you to manage your infrastructure through natural conversation.
TFT-Match-Analyzer - MCP server for teamfight tactics match history & match details fetching, providing user the detailed context for every match.
thegraph-mcp - An MCP server that powers AI agents with indexed blockchain data from The Graph.
Things3 MCP - Things3 task management integration for macOS with comprehensive TODO, project, and tag management.
Think MCP - Enhances any agent’s reasoning capabilities by integrating the think-tools, as described in Anthropic’s article.
Ticketmaster - Search for events, venues, and attractions through the Ticketmaster Discovery API
TickTick - A Model Context Protocol (MCP) server designed to integrate with the TickTick task management platform, enabling intelligent context-aware task operations and automation.
TMDB - This MCP server integrates with The Movie Database (TMDB) API to provide movie information, search capabilities, and recommendations.
Todoist - Interact with Todoist to manage your tasks.
Todos - A practical todo list manager to use with your favourite chatbot.
token-minter-mcp - An MCP server providing tools for AI agents to mint ERC-20 tokens across multiple blockchains.
token-revoke-mcp - An MCP server for checking and revoking ERC-20 token allowances across multiple blockchains.
Ton Blockchain MCP - An MCP server for interacting with Ton Blockchain.
TouchDesigner - An MCP server for TouchDesigner, enabling interaction with TouchDesigner projects, nodes, and parameters.
Travel Planner - Travel planning and itinerary management server integrating with Google Maps API for location search, place details, and route calculations.
Trello MCP Server - An MCP server that interact with user Trello boards, modifying them with prompting.
Tripadvisor - A MCP server that enables LLMs to interact with Tripadvisor API, supporting location data, reviews, and photos through standardized MCP interfaces
Tsuki-Mcp-Filesystem-Server - A simple, fast, and fully MCP-compliant server for listing local filesystem files. Built with Python + FastAPI. Designed for OpenAI’s Agent SDK via resources/list.
Tyk API Management - Chat with all of your organization’s managed APIs and perform other API lifecycle operations, managing tokens, users, analytics, and more.
Typesense - A Model Context Protocol (MCP) server implementation that provides AI models with access to Typesense search capabilities. This server enables LLMs to discover, search, and analyze data stored in Typesense collections.
uniswap-poolspy-mcp - An MCP server that tracks newly created liquidity pools on Uniswap across nine blockchain networks.
uniswap-trader-mcp -An MCP server for AI agents to automate token swaps on Uniswap DEX across multiple blockchains.
Unity Catalog - An MCP server that enables LLMs to interact with Unity Catalog AI, supporting CRUD operations on Unity Catalog Functions and executing them as MCP tools.
Unity Integration (Advanced) - Advanced Unity3d Game Engine MCP which supports ,Execution of Any Editor Related Code Directly Inside of Unity, Fetch Logs, Get Editor State and Allow File Access of the Project making it much more useful in Script Editing or asset creation.
Unity3d Game Engine - An MCP server that enables LLMs to interact with Unity3d Game Engine, supporting access to a variety of the Unit’s Editor engine tools (e.g. Console Logs, Test Runner logs, Editor functions, hierarchy state, etc) and executing them as MCP tools or gather them as resources.
Unleash Integration (Feature Toggle) - A Model Context Protocol (MCP) server implementation that integrates with Unleash Feature Toggle system. Provide a bridge between LLM applications and Unleash feature flag system
User Feedback - Simple MCP Server to enable a human-in-the-loop workflow in tools like Cline and Cursor.
USPTO - MCP server for accessing United States Patent & Trademark Office data through its Open Data Protocol (ODP) API.
Vectara - Query Vectara’s trusted RAG-as-a-service platform.
Vega-Lite - Generate visualizations from fetched data using the VegaLite format and renderer.
Vertica - Vertica database integration in Python with configurable access controls and schema inspection
Vibe Check - An MCP server leveraging an external oversight layer to “vibe check” agents, and also self-improve accuracy & user alignment over time. Prevents scope creep, code bloat, misalignment, misinterpretation, tunnel vision, and overcomplication.
Video Editor - A Model Context Protocol Server to add, edit, and search videos with Video Jungle.
Video Still Capture - 📷 Capture video stills from an OpenCV-compatible webcam or other video source.
Virtual location (Google Street View,etc.) - Integrates Google Map, Google Street View, PixAI, Stability.ai, ComfyUI API and Bluesky to provide a virtual location simulation in LLM (written in Effect.ts)
VolcEngine TOS - A sample MCP server for VolcEngine TOS that flexibly get objects from TOS.
Voyp - VOYP MCP server for making calls using Artificial Intelligence.
Wanaku MCP Router - The Wanaku MCP Router is a SSE-based MCP server that provides an extensible routing engine that allows integrating your enterprise systems with AI agents.
weather-mcp-server - Get real-time weather data for any location using weatherapi.
Webflow - Interfact with the Webflow APIs
whale-tracker-mcp - A mcp server for tracking cryptocurrency whale transactions.
WhatsApp MCP Server - MCP server for your personal WhatsApp handling individuals, groups, searching and sending.
Whois MCP - MCP server that performs whois lookup against domain, IP, ASN and TLD.
Wikidata MCP - Wikidata MCP server that interact with Wikidata, by searching identifiers, extracting metadata, and executing sparql query.
WildFly MCP - WildFly MCP server that enables LLM to interact with running WildFly servers (retrieve metrics, logs, invoke operations, …).
Windows CLI - MCP server for secure command-line interactions on Windows systems, enabling controlled access to PowerShell, CMD, and Git Bash shells.
Workflowy - A server that interacts with workflowy.
World Bank data API - A server that fetches data indicators available with the World Bank as part of their data API
Wren Engine - The Semantic Engine for Model Context Protocol(MCP) Clients and AI Agents
X (Twitter) (by EnesCinr) - Interact with twitter API. Post tweets and search for tweets by query.
X (Twitter) (by vidhupv) - Create, manage and publish X/Twitter posts directly through Claude chat.
Xcode - MCP server that brings AI to your Xcode projects, enabling intelligent code assistance, file operations, project management, and automated development tasks.
xcodebuild - 🍎 Build iOS Xcode workspace/project and feed back errors to llm.
Xero-mcp-server - Enabling clients to interact with Xero system for streamlined accounting, invoicing, and business operations.
XiYan - 🗄️ An MCP server that supports fetching data from a database using natural language queries, powered by XiyanSQL as the text-to-SQL LLM.
XMind - Read and search through your XMind directory containing XMind files.
yfinance -💹The MCP YFinance Stock Server provides real-time and historical stock data in a standard format, powering dashboards, AI agents,and research tools with seamless financial insights.
YNAB - A Model Context Protocol (MCP) server for integrating with YNAB (You Need A Budget), allowing AI assistants to securely access and analyze your financial data.
YouTube - Extract Youtube video information (with proxies support).
YouTube - Comprehensive YouTube API integration for video management, Shorts creation, and analytics.
YouTube Video Summarizer - Summarize lengthy youtube videos.
Zoom - Create, update, read and delete your zoom meetings.

📚 Frameworks

These are high-level frameworks that make it easier to build MCP servers or clients.

For servers

EasyMCP (TypeScript)

FastAPI to MCP auto generator – A zero-configuration tool for automatically exposing FastAPI endpoints as MCP tools by Tadata

FastMCP (TypeScript)
Foxy Contexts – A library to build MCP servers in Golang by strowk
Higress MCP Server Hosting - A solution for hosting MCP Servers by extending the API Gateway (based on Envoy) with wasm plugins.
MCP-Framework Build MCP servers with elegance and speed in Typescript. Comes with a CLI to create your project with mcp create app. Get started with your first server in under 5 minutes by Alex Andru
Quarkus MCP Server SDK (Java)
Spring AI MCP Server - Provides auto-configuration for setting up an MCP server in Spring Boot applications.
Template MCP Server - A CLI tool to create a new Model Context Protocol server project with TypeScript support, dual transport options, and an extensible structure

For clients

codemirror-mcp - CodeMirror extension that implements the Model Context Protocol (MCP) for resource mentions and prompt commands
Spring AI MCP Client - Provides auto-configuration for MCP client functionality in Spring Boot applications.

📚 Resources

Additional resources on MCP.

AiMCP - A collection of MCP clients&servers to find the right mcp tools by Hekmon
Awesome Crypto MCP Servers by badkk - A curated list of MCP servers by Luke Fan
Awesome MCP Servers by appcypher - A curated list of MCP servers by Stephen Akinyemi
Awesome MCP Servers by punkpeye (website) - A curated list of MCP servers by Frank Fiegel
Awesome MCP Servers by wong2 (website) - A curated list of MCP servers by wong2
Awesome Remote MCP Servers by JAW9C - A curated list of remote MCP servers, including thier authentication support by JAW9C
Discord Server – A community discord server dedicated to MCP by Frank Fiegel
Discord Server (ModelContextProtocol) – Connect with developers, share insights, and collaborate on projects in an active Discord community dedicated to the Model Context Protocol by Alex Andru
Klavis AI - Open Source MCP Infra. Hosted MCP servers and MCP clients on Slack and Discord.
MCP Badges – Quickly highlight your MCP project with clear, eye-catching badges, by Ironben
mcp-cli - A CLI inspector for the Model Context Protocol by wong2
mcp-dockmaster - An Open-Sourced UI to install and manage MCP servers for Windows, Linux and MacOS.
mcp-get - Command line tool for installing and managing MCP servers by Michael Latman
mcp-guardian - GUI application + tools for proxying / managing control of MCP servers by EQTY Lab
MCP Linker - A cross-platform Tauri GUI tool for one-click setup and management of MCP servers, supporting Claude Desktop, Cursor, Windsurf, VS Code, Cline, and Neovim.
mcp-manager - Simple Web UI to install and manage MCP servers for Claude Desktop by Zue
MCP Marketplace Web Plugin MCP Marketplace is a small Web UX plugin to integrate with AI applications, Support various MCP Server API Endpoint (e.g pulsemcp.com/deepnlp.org and more). Allowing user to browse, paginate and select various MCP servers by different categories. Pypi | Maintainer | Website
mcp.natoma.id – A Hosted MCP Platform to discover, install, manage and deploy MCP servers by Natoma Labs
mcp.run - A hosted registry and control plane to install & run secure + portable MCP Servers.
MCP Router – Free Windows and macOS app that simplifies MCP management while providing seamless app authentication and powerful log visualization by MCP Router
MCP Servers Hub (website) - A curated list of MCP servers by apappascs
MCP Servers Rating and User Reviews - Website to rate MCP servers, write authentic user reviews, and search engine for agent & mcp
MCP X Community – A X community for MCP by Xiaoyi
MCPHub – An Open Source macOS & Windows GUI Desktop app for discovering, installing and managing MCP servers by Jeamee
mcpm (website) - MCP Manager (MCPM) is a Homebrew-like service for managing Model Context Protocol (MCP) servers across clients by Pathintegral
MCPVerse - A portal for creating & hosting authenticated MCP servers and connecting to them securely.
MCPWatch - A comprehensive security scanner for Model Context Protocol (MCP) servers that detects vulnerabilities and security issues in your MCP server implementations.
mkinf - An Open Source registry of hosted MCP Servers to accelerate AI agent workflows.
Open-Sourced MCP Servers Directory - A curated list of MCP servers by mcpso
OpenTools - An open registry for finding, installing, and building with MCP servers by opentoolsteam
PulseMCP (API) - Community hub & weekly newsletter for discovering MCP servers, clients, articles, and news by Tadas Antanavicius, Mike Coughlin, and Ravina Patel
r/mcp – A Reddit community dedicated to MCP by Frank Fiegel
r/modelcontextprotocol – A Model Context Protocol community Reddit page - discuss ideas, get answers to your questions, network with like-minded people, and showcase your projects! by Alex Andru
Smithery - A registry of MCP servers to find the right tools for your LLM agents by Henry Mao
Toolbase - Desktop application that manages tools and MCP servers with just a few clicks - no coding required by gching
ToolHive - A lightweight utility designed to simplify the deployment and management of MCP servers, ensuring ease of use, consistency, and security through containerization by StacklokLabs

🚀 Getting Started

Using MCP Servers in this Repository

Typescript-based servers in this repository can be used directly with npx.

For example, this will start the Memory server:

`1`	`npx -y @modelcontextprotocol/server-memory`

Python-based servers in this repository can be used directly with uvx or pip. uvx is recommended for ease of use and setup.

For example, this will start the Git server:

# With uvx
uvx mcp-server-git

# With pip
pip install mcp-server-git
python -m mcp_server_git

Follow these instructions to install uv / uvx and these to install pip.

Using an MCP Client

However, running a server on its own isn’t very useful, and should instead be configured into an MCP client. For example, here’s the Claude Desktop configuration to use the above server:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Additional examples of using the Claude Desktop as an MCP client might look like:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "path/to/git/repo"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}

🛠️ Creating Your Own Server

Interested in creating your own MCP server? Visit the official documentation at modelcontextprotocol.io for comprehensive guides, best practices, and technical details on implementing MCP servers.

🤝 Contributing

See CONTRIBUTING.md for information about contributing to this repository.

🔒 Security

See SECURITY.md for reporting security vulnerabilities.

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

💬 Community

GitHub Discussions

⭐ Support

If you find MCP servers useful, please consider starring the repository and contributing new servers or improvements!

Managed by Anthropic, but built together with the community. The Model Context Protocol is open source and we encourage everyone to contribute their own servers and improvements!

NeMo

Sat, 10 May 2025 15:25:32 +0800

NVIDIA/NeMo

NVIDIA NeMo Framework

Latest News

Pretrain and finetune :hugs:Hugging Face models via AutoModel

Nemo Framework's latest feature AutoModel enables broad support for :hugs:Hugging Face models, with 25.02 focusing on AutoModelForCausalLM in the text generation category . Future releases will enable support for more model families such as Vision Language Model.

Training on Blackwell using Nemo

NeMo Framework has added Blackwell support, with 25.02 focusing on functional parity for B200. More optimizations to come in the upcoming releases.

NeMo Framework 2.0

We've released NeMo 2.0, an update on the NeMo Framework which prioritizes modularity and ease-of-use. Please refer to the NeMo Framework User Guide to get started.

New Cosmos World Foundation Models Support

Advancing Physical AI with NVIDIA Cosmos World Foundation Model Platform (2025-01-09)

The end-to-end NVIDIA Cosmos platform accelerates world model development for physical AI systems. Built on CUDA, Cosmos combines state-of-the-art world foundation models, video tokenizers, and AI-accelerated data processing pipelines. Developers can accelerate world model development by fine-tuning Cosmos world foundation models or building new ones from the ground up. These models create realistic synthetic videos of environments and interactions, providing a scalable foundation for training complex systems, from simulating humanoid robots performing advanced actions to developing end-to-end autonomous driving models.

Accelerate Custom Video Foundation Model Pipelines with New NVIDIA NeMo Framework Capabilities (2025-01-07)

The NeMo Framework now supports training and customizing the NVIDIA Cosmos collection of world foundation models. Cosmos leverages advanced text-to-world generation techniques to create fluid, coherent video content from natural language prompts.

You can also now accelerate your video processing step using the NeMo Curator library, which provides optimized video processing and captioning features that can deliver up to 89x faster video processing when compared to an unoptimized CPU pipeline.

Large Language Models and Multimodal Models

State-of-the-Art Multimodal Generative AI Model Development with NVIDIA NeMo (2024-11-06)

NVIDIA recently announced significant enhancements to the NeMo platform, focusing on multimodal generative AI models. The update includes NeMo Curator and the Cosmos tokenizer, which streamline the data curation process and enhance the quality of visual data. These tools are designed to handle large-scale data efficiently, making it easier to develop high-quality AI models for various applications, including robotics and autonomous driving. The Cosmos tokenizers, in particular, efficiently map visual data into compact, semantic tokens, which is crucial for training large-scale generative models. The tokenizer is available now on the NVIDIA/cosmos-tokenizer GitHub repo and on Hugging Face.

New Llama 3.1 Support (2024-07-23)

The NeMo Framework now supports training and customizing the Llama 3.1 collection of LLMs from Meta.

Accelerate your Generative AI Distributed Training Workloads with the NVIDIA NeMo Framework on Amazon EKS (2024-07-16)

NVIDIA NeMo Framework now runs distributed training workloads on an Amazon Elastic Kubernetes Service (Amazon EKS) cluster. For step-by-step instructions on creating an EKS cluster and running distributed training workloads with NeMo, see the GitHub repository here.

NVIDIA NeMo Accelerates LLM Innovation with Hybrid State Space Model Support (2024/06/17)

NVIDIA NeMo and Megatron Core now support pre-training and fine-tuning of state space models (SSMs). NeMo also supports training models based on the Griffin architecture as described by Google DeepMind.

NVIDIA releases 340B base, instruct, and reward models pretrained on a total of 9T tokens. (2024-06-18)

See documentation and tutorials for SFT, PEFT, and PTQ with Nemotron 340B in the NeMo Framework User Guide.

NVIDIA sets new generative AI performance and scale records in MLPerf Training v4.0 (2024/06/12)

Using NVIDIA NeMo Framework and NVIDIA Hopper GPUs NVIDIA was able to scale to 11,616 H100 GPUs and achieve near-linear performance scaling on LLM pretraining. NVIDIA also achieved the highest LLM fine-tuning performance and raised the bar for text-to-image training.

Accelerate your generative AI journey with NVIDIA NeMo Framework on GKE (2024/03/16)

An end-to-end walkthrough to train generative AI models on the Google Kubernetes Engine (GKE) using the NVIDIA NeMo Framework is available at https://github.com/GoogleCloudPlatform/nvidia-nemo-on-gke. The walkthrough includes detailed instructions on how to set up a Google Cloud Project and pre-train a GPT model using the NeMo Framework.

Speech Recognition

Accelerating Leaderboard-Topping ASR Models 10x with NVIDIA NeMo (2024/09/24)

NVIDIA NeMo team released a number of inference optimizations for CTC, RNN-T, and TDT models that resulted in up to 10x inference speed-up. These models now exceed an inverse real-time factor (RTFx) of 2,000, with some reaching RTFx of even 6,000.

New Standard for Speech Recognition and Translation from the NVIDIA NeMo Canary Model (2024/04/18)

The NeMo team just released Canary, a multilingual model that transcribes speech in English, Spanish, German, and French with punctuation and capitalization. Canary also provides bi-directional translation, between English and the three other supported languages.

Pushing the Boundaries of Speech Recognition with NVIDIA NeMo Parakeet ASR Models (2024/04/18)

NVIDIA NeMo, an end-to-end platform for the development of multimodal generative AI models at scale anywhere—on any cloud and on-premises—released the Parakeet family of automatic speech recognition (ASR) models. These state-of-the-art ASR models, developed in collaboration with Suno.ai, transcribe spoken English with exceptional accuracy.

Turbocharge ASR Accuracy and Speed with NVIDIA NeMo Parakeet-TDT (2024/04/18)

NVIDIA NeMo, an end-to-end platform for developing multimodal generative AI models at scale anywhere—on any cloud and on-premises—recently released Parakeet-TDT. This new addition to the  NeMo ASR Parakeet model family boasts better accuracy and 64% greater speed over the previously best model, Parakeet-RNNT-1.1B.

Introduction

NVIDIA NeMo Framework is a scalable and cloud-native generative AI framework built for researchers and PyTorch developers working on Large Language Models (LLMs), Multimodal Models (MMs), Automatic Speech Recognition (ASR), Text to Speech (TTS), and Computer Vision (CV) domains. It is designed to help you efficiently create, customize, and deploy new generative AI models by leveraging existing code and pre-trained model checkpoints.

For technical documentation, please see the NeMo Framework User Guide.

What’s New in NeMo 2.0

NVIDIA NeMo 2.0 introduces several significant improvements over its predecessor, NeMo 1.0, enhancing flexibility, performance, and scalability.

Python-Based Configuration - NeMo 2.0 transitions from YAML files to a Python-based configuration, providing more flexibility and control. This shift makes it easier to extend and customize configurations programmatically.
Modular Abstractions - By adopting PyTorch Lightning’s modular abstractions, NeMo 2.0 simplifies adaptation and experimentation. This modular approach allows developers to more easily modify and experiment with different components of their models.
Scalability - NeMo 2.0 seamlessly scaling large-scale experiments across thousands of GPUs using NeMo-Run, a powerful tool designed to streamline the configuration, execution, and management of machine learning experiments across computing environments.

Overall, these enhancements make NeMo 2.0 a powerful, scalable, and user-friendly framework for AI model development.

[!IMPORTANT]
NeMo 2.0 is currently supported by the LLM (large language model) and VLM (vision language model) collections.

Get Started with NeMo 2.0

Refer to the Quickstart for examples of using NeMo-Run to launch NeMo 2.0 experiments locally and on a slurm cluster.
For more information about NeMo 2.0, see the NeMo Framework User Guide.
NeMo 2.0 Recipes contains additional examples of launching large-scale runs using NeMo 2.0 and NeMo-Run.
For an in-depth exploration of the main features of NeMo 2.0, see the Feature Guide.
To transition from NeMo 1.0 to 2.0, see the Migration Guide for step-by-step instructions.

Get Started with Cosmos

NeMo Curator and NeMo Framework support video curation and post-training of the Cosmos World Foundation Models, which are open and available on NGC and Hugging Face. For more information on video datasets, refer to NeMo Curator. To post-train World Foundation Models using the NeMo Framework for your custom physical AI tasks, see the Cosmos Diffusion models and the Cosmos Autoregressive models.

LLMs and MMs Training, Alignment, and Customization

All NeMo models are trained with Lightning. Training is automatically scalable to 1000s of GPUs. You can check the performance benchmarks using the latest NeMo Framework container here.

When applicable, NeMo models leverage cutting-edge distributed training techniques, incorporating parallelism strategies to enable efficient training of very large models. These techniques include Tensor Parallelism (TP), Pipeline Parallelism (PP), Fully Sharded Data Parallelism (FSDP), Mixture-of-Experts (MoE), and Mixed Precision Training with BFloat16 and FP8, as well as others.

NeMo Transformer-based LLMs and MMs utilize NVIDIA Transformer Engine for FP8 training on NVIDIA Hopper GPUs, while leveraging NVIDIA Megatron Core for scaling Transformer model training.

NeMo LLMs can be aligned with state-of-the-art methods such as SteerLM, Direct Preference Optimization (DPO), and Reinforcement Learning from Human Feedback (RLHF). See NVIDIA NeMo Aligner for more information.

In addition to supervised fine-tuning (SFT), NeMo also supports the latest parameter efficient fine-tuning (PEFT) techniques such as LoRA, P-Tuning, Adapters, and IA3. Refer to the NeMo Framework User Guide for the full list of supported models and techniques.

LLMs and MMs Deployment and Optimization

NeMo LLMs and MMs can be deployed and optimized with NVIDIA NeMo Microservices.

Speech AI

NeMo ASR and TTS models can be optimized for inference and deployed for production use cases with NVIDIA Riva.

NeMo Framework Launcher

[!IMPORTANT]
NeMo Framework Launcher is compatible with NeMo version 1.0 only. NeMo-Run is recommended for launching experiments using NeMo 2.0.

NeMo Framework Launcher is a cloud-native tool that streamlines the NeMo Framework experience. It is used for launching end-to-end NeMo Framework training jobs on CSPs and Slurm clusters.

The NeMo Framework Launcher includes extensive recipes, scripts, utilities, and documentation for training NeMo LLMs. It also includes the NeMo Framework Autoconfigurator, which is designed to find the optimal model parallel configuration for training on a specific cluster.

To get started quickly with the NeMo Framework Launcher, please see the NeMo Framework Playbooks. The NeMo Framework Launcher does not currently support ASR and TTS training, but it will soon.

Get Started with NeMo Framework

Getting started with NeMo Framework is easy. State-of-the-art pretrained NeMo models are freely available on Hugging Face Hub and NVIDIA NGC. These models can be used to generate text or images, transcribe audio, and synthesize speech in just a few lines of code.

We have extensive tutorials that can be run on Google Colab or with our NGC NeMo Framework Container. We also have playbooks for users who want to train NeMo models with the NeMo Framework Launcher.

For advanced users who want to train NeMo models from scratch or fine-tune existing NeMo models, we have a full suite of example scripts that support multi-GPU/multi-node training.

Key Features

Requirements

Python 3.10 or above
Pytorch 2.5 or above
NVIDIA GPU (if you intend to do model training)

Developer Documentation

Version	Status	Description
Latest		Documentation of the latest (i.e. main) branch.
Stable		Documentation of the stable (i.e. most recent release)

Install NeMo Framework

The NeMo Framework can be installed in a variety of ways, depending on your needs. Depending on the domain, you may find one of the following installation methods more suitable.

Conda / Pip: Install NeMo-Framework with native Pip into a virtual environment.
- Used to explore NeMo on any supported platform.
- This is the recommended method for ASR and TTS domains.
- Limited feature-completeness for other domains.
NGC PyTorch container: Install NeMo-Framework from source with feature-completeness into a highly optimized container.
- For users that want to install from source in a highly optimized container.
NGC NeMo container: Ready-to-go solution of NeMo-Framework
- For users that seek highest performance.
- Contains all dependencies installed and tested for performance and convergence.

Support matrix

NeMo-Framework provides tiers of support based on OS / Platform and mode of installation. Please refer the following overview of support levels:

Fully supported: Max performance and feature-completeness.
Limited supported: Used to explore NeMo.
No support yet: In development.
Deprecated: Support has reached end of life.

Please refer to the following table for current support levels:

OS / Platform	Install from PyPi	Source into NGC container
`linux` - `amd64/x84_64`	Limited support	Full support
`linux` - `arm64`	Limited support	Limited support
`darwin` - `amd64/x64_64`	Deprecated	Deprecated
`darwin` - `arm64`	Limited support	Limited support
`windows` - `amd64/x64_64`	No support yet	No support yet
`windows` - `arm64`	No support yet	No support yet

Conda / Pip

Install NeMo in a fresh Conda environment:

1
2

conda create --name nemo python==3.10.12
conda activate nemo

Pick the right version

NeMo-Framework publishes pre-built wheels with each release. To install nemo_toolkit from such a wheel, use the following installation method:

`1`	`pip install "nemo_toolkit[all]"`

If a more specific version is desired, we recommend a Pip-VCS install. From NVIDIA/NeMo, fetch the commit, branch, or tag that you would like to install.
To install nemo_toolkit from this Git reference $REF, use the following installation method:

git clone https://github.com/NVIDIA/NeMo
cd NeMo
git checkout @${REF:-'main'}
pip install '.[all]'

Install a specific Domain

To install a specific domain of NeMo, you must first install the nemo_toolkit using the instructions listed above. Then, you run the following domain-specific commands:

pip install nemo_toolkit['all'] # or pip install "nemo_toolkit['all']@git+https://github.com/NVIDIA/NeMo@${REF:-'main'}"
pip install nemo_toolkit['asr'] # or pip install "nemo_toolkit['asr']@git+https://github.com/NVIDIA/NeMo@$REF:-'main'}"
pip install nemo_toolkit['nlp'] # or pip install "nemo_toolkit['nlp']@git+https://github.com/NVIDIA/NeMo@${REF:-'main'}"
pip install nemo_toolkit['tts'] # or pip install "nemo_toolkit['tts']@git+https://github.com/NVIDIA/NeMo@${REF:-'main'}"
pip install nemo_toolkit['vision'] # or pip install "nemo_toolkit['vision']@git+https://github.com/NVIDIA/NeMo@${REF:-'main'}"
pip install nemo_toolkit['multimodal'] # or pip install "nemo_toolkit['multimodal']@git+https://github.com/NVIDIA/NeMo@${REF:-'main'}"

NGC PyTorch container

NOTE: The following steps are supported beginning with 24.04 (NeMo-Toolkit 2.3.0)

We recommended that you start with a base NVIDIA PyTorch container: nvcr.io/nvidia/pytorch:25.01-py3.

If starting with a base NVIDIA PyTorch container, you must first launch the container:

docker run \
  --gpus all \
  -it \
  --rm \
  --shm-size=16g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  nvcr.io/nvidia/pytorch:${NV_PYTORCH_TAG:-'nvcr.io/nvidia/pytorch:25.01-py3'}

From NVIDIA/NeMo, fetch the commit/branch/tag that you want to install.
To install nemo_toolkit including all of its dependencies from this Git reference $REF, use the following installation method:

cd /opt
git clone https://github.com/NVIDIA/NeMo
cd NeMo
git checkout ${REF:-'main'}
bash reinstall.sh --library all

NGC NeMo container

NeMo containers are launched concurrently with NeMo version updates. NeMo Framework now supports LLMs, MMs, ASR, and TTS in a single consolidated Docker container. You can find additional information about released containers on the NeMo releases page.

To use a pre-built container, run the following code:

docker run \
  --gpus all \
  -it \
  --rm \
  --shm-size=16g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  nvcr.io/nvidia/pytorch:${NV_PYTORCH_TAG:-'nvcr.io/nvidia/nemo:25.02'}

Future Work

The NeMo Framework Launcher does not currently support ASR and TTS training, but it will soon.

Discussions Board

FAQ can be found on the NeMo Discussions board. You are welcome to ask questions or start discussions on the board.

Contribute to NeMo

We welcome community contributions! Please refer to CONTRIBUTING.md for the process.

Publications

We provide an ever-growing list of publications that utilize the NeMo Framework.

To contribute an article to the collection, please submit a pull request to the gh-pages-src branch of this repository. For detailed information, please consult the README located at the gh-pages-src branch.

Blogs

Large Language Models and Multimodal Models

Bria Builds Responsible Generative AI for Enterprises Using NVIDIA NeMo, Picasso (2024/03/06)

Bria, a Tel Aviv startup at the forefront of visual generative AI for enterprises now leverages the NVIDIA NeMo Framework. The Bria.ai platform uses reference implementations from the NeMo Multimodal collection, trained on NVIDIA Tensor Core GPUs, to enable high-throughput and low-latency image generation. Bria has also adopted NVIDIA Picasso, a foundry for visual generative AI models, to run inference.

New NVIDIA NeMo Framework Features and NVIDIA H200 (2023/12/06)

NVIDIA NeMo Framework now includes several optimizations and enhancements, including: 1) Fully Sharded Data Parallelism (FSDP) to improve the efficiency of training large-scale AI models, 2) Mix of Experts (MoE)-based LLM architectures with expert parallelism for efficient LLM training at scale, 3) Reinforcement Learning from Human Feedback (RLHF) with TensorRT-LLM for inference stage acceleration, and 4) up to 4.2x speedups for Llama 2 pre-training on NVIDIA H200 Tensor Core GPUs.

NVIDIA now powers training for Amazon Titan Foundation models (2023/11/28)

NVIDIA NeMo Framework now empowers the Amazon Titan foundation models (FM) with efficient training of large language models (LLMs). The Titan FMs form the basis of Amazon’s generative AI service, Amazon Bedrock. The NeMo Framework provides a versatile framework for building, customizing, and running LLMs.

Licenses

NeMo GitHub Apache 2.0 license
NeMo is licensed under the NVIDIA AI PRODUCT AGREEMENT. By pulling and using the container, you accept the terms and conditions of this license.

agents-course

Thu, 08 May 2025 15:30:23 +0800

huggingface/agents-course

The Hugging Face Agents Course

If you like the course, don’t hesitate to ⭐ star this repository. This helps us to make the course more visible 🤗.

Content

The course is divided into 4 units. These will take you from the basics of agents to a final assignment with a benchmark.

You can access the course here 👉 https://hf.co/learn/agents-course

Unit	Topic	Description
0	Welcome to the Course	Welcome, guidelines, necessary tools, and course overview.
1	Introduction to Agents	Definition of agents, LLMs, model family tree, and special tokens.
1 Bonus	Fine-tuning an LLM for Function-calling	Learn how to fine-tune an LLM for Function-Calling
2	Frameworks for AI Agents	Overview of `smolagents`, `LangGraph` and `LlamaIndex`.
2.1	The Smolagents Framework	Learn how to build effective agents using the `smolagents` library, a lightweight framework for creating capable AI agents.
2.2	The LlamaIndex Framework	Learn how to build LLM-powered agents over your data using indexes and workflows using the `LlamaIndex` toolkit.
2.3	The LangGraph Framework	Learn how to build production-ready applications using the `LangGraph` framework giving you control tools over the flow of your agent.
2 Bonus	Observability and Evaluation	Learn how to trace and evaluate your agents.
3	Use Case for Agentic RAG	Learn how to use Agentic RAG to help agents respond to different use cases using various frameworks.
4	Final Project - Create, Test and Certify Your Agent	Automated evaluation of agents and leaderboard with student results.

Prerequisites

Basic knowledge of Python
Basic knowledge of LLMs

Contribution Guidelines

If you want to contribute to this course, you’re welcome to do so. Feel free to open an issue or join the discussion in the Discord. For specific contributions, here are some guidelines:

Small typo and grammar fixes

If you find a small typo or grammar mistake, please fix it yourself and submit a pull request. This is very helpful for students.

New unit

If you want to add a new unit, please create an issue in the repository, describe the unit, and why it should be added. We will discuss it and if it’s a good addition, we can collaborate on it.

Citing the project

To cite this repository in publications:

@misc{agents-course,
  author = {Burtenshaw, Ben and Thomas, Joffrey and Simonini, Thomas and Paniego, Sergio},
  title = {The Hugging Face Agents Course},
  year = {2025},
  howpublished = {\url{https://github.com/huggingface/agents-course}},
  note = {GitHub repository},
}

web-ui

Sat, 05 Apr 2025 15:25:18 +0800

browser-use/web-ui

This project builds upon the foundation of the browser-use, which is designed to make websites accessible for AI agents.

We would like to officially thank WarmShao for his contribution to this project.

WebUI: is built on Gradio and supports most of browser-use functionalities. This UI is designed to be user-friendly and enables easy interaction with the browser agent.

Expanded LLM Support: We’ve integrated support for various Large Language Models (LLMs), including: Google, OpenAI, Azure OpenAI, Anthropic, DeepSeek, Ollama etc. And we plan to add support for even more models in the future.

Custom Browser Support: You can use your own browser with our tool, eliminating the need to re-login to sites or deal with other authentication challenges. This feature also supports high-definition screen recording.

Persistent Browser Sessions: You can choose to keep the browser window open between AI tasks, allowing you to see the complete history and state of AI interactions.

Your browser does not support playing this video!

Installation Guide

Prerequisites

Python 3.11 or higher
Git (for cloning the repository)

Option 1: Local Installation

Read the quickstart guide or follow the steps below to get started.

Step 1: Clone the Repository

1
2

git clone https://github.com/browser-use/web-ui.git
cd web-ui

Step 2: Set Up Python Environment

We recommend using uv for managing the Python environment.

Using uv (recommended):

`1`	`uv venv --python 3.11`

Activate the virtual environment:

Windows (Command Prompt):

`1`	`.venv\Scripts\activate`

Windows (PowerShell):

`1`	`.\.venv\Scripts\Activate.ps1`

macOS/Linux:

`1`	`source .venv/bin/activate`

Step 3: Install Dependencies

Install Python packages:

`1`	`uv pip install -r requirements.txt`

Install Browsers in Playwright: You can install specific browsers by running:

`1`	`playwright install --with-deps chromium`

To install all browsers:

`1`	`playwright install`

Step 4: Configure Environment

Create a copy of the example environment file:

Windows (Command Prompt):

`1`	`copy .env.example .env`

macOS/Linux/Windows (PowerShell):

`1`	`cp .env.example .env`

Open .env in your preferred text editor and add your API keys and other settings

Option 2: Docker Installation

Prerequisites

Docker and Docker Compose installed
- Docker Desktop (For Windows/macOS)
- Docker Engine and Docker Compose (For Linux)

Installation Steps

Clone the repository:

1
2

git clone https://github.com/browser-use/web-ui.git
cd web-ui

Create and configure environment file:

Windows (Command Prompt):

`1`	`copy .env.example .env`

macOS/Linux/Windows (PowerShell):

`1`	`cp .env.example .env`

Edit .env with your preferred text editor and add your API keys

Run with Docker:

1
2

# Build and start the container with default settings (browser closes after AI tasks)
docker compose up --build

1
2

# Or run with persistent browser (browser stays open between AI tasks)
CHROME_PERSISTENT_SESSION=true docker compose up --build

Access the Application:

Web Interface: Open http://localhost:7788 in your browser
VNC Viewer (for watching browser interactions): Open http://localhost:6080/vnc.html
- Default VNC password: “youvncpassword”
- Can be changed by setting VNC_PASSWORD in your .env file

Usage

Local Setup

Run the WebUI: After completing the installation steps above, start the application:
1

python webui.py --ip 127.0.0.1 --port 7788
WebUI options:
- --ip: The IP address to bind the WebUI to. Default is 127.0.0.1.
- --port: The port to bind the WebUI to. Default is 7788.
- --theme: The theme for the user interface. Default is Ocean.
  - Default: The standard theme with a balanced design.
  - Soft: A gentle, muted color scheme for a relaxed viewing experience.
  - Monochrome: A grayscale theme with minimal color for simplicity and focus.
  - Glass: A sleek, semi-transparent design for a modern appearance.
  - Origin: A classic, retro-inspired theme for a nostalgic feel.
  - Citrus: A vibrant, citrus-inspired palette with bright and fresh colors.
  - Ocean (default): A blue, ocean-inspired theme providing a calming effect.
- --dark-mode: Enables dark mode for the user interface.
Access the WebUI: Open your web browser and navigate to http://127.0.0.1:7788.
Using Your Own Browser(Optional):
- Set CHROME_PATH to the executable path of your browser and CHROME_USER_DATA to the user data directory of your browser. Leave CHROME_USER_DATA empty if you want to use local user data.
  - Windows
    1 2
    
    CHROME_PATH="C:\Program Files\Google\Chrome\Application\chrome.exe" CHROME_USER_DATA="C:\Users\YourUsername\AppData\Local\Google\Chrome\User Data"
    Note: Replace YourUsername with your actual Windows username for Windows systems.
  - Mac
    1 2
    
    CHROME_PATH="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" CHROME_USER_DATA="/Users/YourUsername/Library/Application Support/Google/Chrome"
- Close all Chrome windows
- Open the WebUI in a non-Chrome browser, such as Firefox or Edge. This is important because the persistent browser context will use the Chrome data when running the agent.
- Check the “Use Own Browser” option within the Browser Settings.
Keep Browser Open(Optional):
- Set CHROME_PERSISTENT_SESSION=true in the .env file.

Docker Setup

Environment Variables:

All configuration is done through the .env file

Available environment variables:

# LLM API Keys
OPENAI_API_KEY=your_key_here
ANTHROPIC_API_KEY=your_key_here
GOOGLE_API_KEY=your_key_here

# Browser Settings
CHROME_PERSISTENT_SESSION=true   # Set to true to keep browser open between AI tasks
RESOLUTION=1920x1080x24         # Custom resolution format: WIDTHxHEIGHTxDEPTH
RESOLUTION_WIDTH=1920           # Custom width in pixels
RESOLUTION_HEIGHT=1080          # Custom height in pixels

# VNC Settings
VNC_PASSWORD=your_vnc_password  # Optional, defaults to "vncpassword"

Platform Support:
- Supports both AMD64 and ARM64 architectures
- For ARM64 systems (e.g., Apple Silicon Macs), the container will automatically use the appropriate image
Browser Persistence Modes:
- Default Mode (CHROME_PERSISTENT_SESSION=false):
  - Browser opens and closes with each AI task
  - Clean state for each interaction
  - Lower resource usage
- Persistent Mode (CHROME_PERSISTENT_SESSION=true):
  - Browser stays open between AI tasks
  - Maintains history and state
  - Allows viewing previous AI interactions
  - Set in .env file or via environment variable when starting container
Viewing Browser Interactions:
- Access the noVNC viewer at http://localhost:6080/vnc.html
- Enter the VNC password (default: “vncpassword” or what you set in VNC_PASSWORD)
- Direct VNC access available on port 5900 (mapped to container port 5901)
- You can now see all browser interactions in real-time

Container Management:

# Start with persistent browser
CHROME_PERSISTENT_SESSION=true docker compose up -d

# Start with default mode (browser closes after tasks)
docker compose up -d

# View logs
docker compose logs -f

# Stop the container
docker compose down

Changelog

2025/01/26: Thanks to @vvincent1234. Now browser-use-webui can combine with DeepSeek-r1 to engage in deep thinking!
2025/01/10: Thanks to @casistack. Now we have Docker Setup option and also Support keep browser open between tasks.Video tutorial demo.
2025/01/06: Thanks to @richard-devbot. A New and Well-Designed WebUI is released. Video tutorial demo.

LLMs on Producthunt daily

skyvern

How it works

Demo

Performance & Evaluation

Performance on WRITE tasks (eg filling out forms, logging in, downloading files, etc)

Quickstart

Skyvern Cloud

Install & Run

1. Install Skyvern

2. Run Skyvern

3. Run task

UI (Recommended)

Code

Advanced Usage

Control your own browser (Chrome)

Run Skyvern with any remote browser

Get consistent output schema from your run

Helpful commands to debug issues

Docker Compose setup

Skyvern Features

Skyvern Tasks

Skyvern Workflows

Livestreaming

Form Filling

Data Extraction

File Downloading

Authentication

🔐 2FA Support (TOTP)

Password Manager Integrations

Model Context Protocol (MCP)

Zapier / Make.com / N8N Integration

Real-world examples of Skyvern

Invoice Downloading on many different websites

Automate the job application process

Automate materials procurement for a manufacturing company

Navigating to government websites to register accounts or fill out forms

Filling out random contact us forms

Retrieving insurance quotes from insurance providers in any language

Contributor Setup

Documentation

Supported LLMs

Environment Variables

OpenAI

Anthropic

Azure OpenAI

AWS Bedrock

Gemini

Ollama

OpenRouter

OpenAI-Compatible

General LLM Configuration

Feature Roadmap

Contributing

Telemetry

License

Star History

langchainjs

🦜️🔗 LangChain.js

⚡️ Quick Install

🌐 Supported Environments

🤔 What is LangChain?

🚀 How does LangChain help?

📖 Additional Resources

💁 Contributing

🖇️ Relationship with Python LangChain

Prompt-Engineering-Guide

Prompt Engineering Guide

Sponsored by

Announcements / Updates

Guides

Lecture

Running the guide locally

Appearances

License

aisheets

🤗 Hugging Face AI Sheets

What’s AI Sheets?

Quick Start

Using the AI Sheets Space