newtype.
ArticleOctober 10, 2025Free to read

Goodbye, GPTs

OpenGPTs is an open-source project launched by LangChain, intended to replace OpenAI's GPTs and offer more thorough customization capabilities.

Originally published . English translation: . Read the Chinese original.

Original video in Chinese.

Key Takeaway

  • OpenGPTs is an open-source project launched by LangChain, intended to replace OpenAI’s GPTs and offer more thorough customization capabilities.
  • OpenGPTs supports more models (open-source, closed-source, cloud-based, local), can run entirely locally, keeps data safer, offers stronger privacy, and costs less.
  • OpenGPTs is highly customizable, the code is open, you can modify it however you want, and it can generate public links for team sharing.
  • OpenGPTs’ functional modules include Chatbot (model selection, instruction settings), RAG (retrieval-augmented generation, supports document retrieval), and Application (Chatbot + RAG + tools).
  • OpenGPTs provides a variety of tools, such as general search and vertical search tools, making up for the shortcomings of ChatGPT’s tools.
  • The real potential of OpenGPTs lies in customization and secondary development, giving users an extremely high degree of freedom.

Full Content

After watching this video, you won’t need ChatGPT anymore. Because you can completely replace it with OpenGPTs, and do it better.

OpenGPTs is an open-source project launched by LangChain some time ago. It looks the same as OpenAI’s GPTs, supporting a certain degree of customization. For example, you can upload documents as a knowledge base, and you can add tools such as text-to-image and online search. But to be honest, if you want AI to become a truly intelligent assistant, this level is still far from enough.

OpenGPTs goes further in customization:

  • It supports more models, not just OpenAI’s. Open-source, closed-source, cloud-based, and local models are all supported.
  • It can run completely locally. Not only does the large language model run locally, but the documents in the knowledge base are also stored locally, so data is safer, privacy is stronger, and the cost is lower.
  • Highly customizable. The code is fully open, and you can modify it however you want. It’s extremely fun to play with. The reason I made the newtype project last year was that I wasn’t satisfied with ChatGPT and wanted a higher degree of freedom.
  • After everything is modified, you can also generate a public link. For example, you can give it to a team for shared use. That’s fantastic!

Installing OpenGPTs is a bit troublesome. If you want to try it first before deciding, the official site has a ready-made demo, and I’ll use that to introduce it in detail.

OpenGPTs has only three functional modules: Chatbot, Rag, and Application. Don’t be fooled by the fact that there are only three; together, these three cover every type of GPT application.

Chatbot is very simple, with just two settings:

First, choose the large language model.

In the demo, the official version lists all the current mainstream large language models: the big three GPT, Claude, Gemini, and the European Mixtral.

If you want to use another large language model, such as running an open-source large language model through Ollama, just find the app folder inside the backend folder and make a small modification to llms.py.

Second, give instructions, which is the familiar Prompt. With this setting, the AI will run according to the role, personality, and working style you want.

For example, we can create a bot specifically for translating tech articles.

First define the role and task:

You are a professional translator proficient in Simplified Chinese, especially skilled at translating professional academic papers into easy-to-understand popular science articles. I hope you can help me translate the following English paper passages into Chinese, in a style similar to the Chinese version of a popular science magazine.

Then define the rules:

  • Translation must accurately convey the facts and background of the original text.
  • Even if you use free translation, you must preserve the original paragraph format, and preserve terms such as FLAC, JPEG, etc. Preserve company abbreviations such as Microsoft, Amazon, etc.
  • You must also preserve cited papers, such as citations like [20].
  • For Figure and Table, preserve the original format while translating, for example: “Figure 1: “ should be translated as “图 1: “, and “Table 1: “ should be translated as “表 1: “.
  • Replace full-width parentheses with half-width parentheses, and add a half-width space before the left parenthesis and a half-width space after the right parenthesis.
  • The input format is Markdown, and the output format must also preserve the original Markdown format.
  • The following is a correspondence table of common AI-related terms:
    • Transformer -> Transformer
    • Token -> Token
    • LLM/Large Language Model -> 大语言模型
    • Generative AI -> 生成式 AI

Finally, define the strategy:

Translate in two passes:

  1. Translate the English content literally, keeping the original format and not omitting any information
  2. Based on the result of the first literal translation, rewrite it into a freer translation, making the content more understandable and more in line with Chinese expression habits while still preserving the original format

I copied two paragraphs from a paper and pasted them in. The translation bot gave me the literal translation and the free translation in two rounds, and the result was pretty good.

This is the most common use case. The difficulty is that you have to understand the task from the AI’s perspective and then break it down. For example, with that translation bot, if you just let it translate directly instead of doing literal translation first and then free translation, the output definitely wouldn’t be very good. In the AI era, this kind of thinking is very important, and everyone must have it.

Chatbot only invokes the general knowledge of the large language model. If you want AI to also have domain knowledge, then you need to use the second function — RAG.

RAG stands for retrieval-augmented generation. Like fine-tuning, it also belongs to giving the large language model “special tutoring” — fine-tuning is like sending the large language model to cram school again to strengthen certain subjects; RAG is like buying the large language model a pile of study materials so it can look things up whenever needed.

When the LangChain team developed the RAG feature, they hard-coded it so that the AI would retrieve documents every time it answered. So if you want to have a conversation based on a certain document, this function is the most direct choice.

Let me give you a demo. Upload the AutoGen paper, then ask: What is autogen?

You can see that the AI started the Retrieval Function and, based on the question, found several relevant passages in the document. It then gave its answer with reference to these passages.

Don’t think RAG is that simple. When I was developing newtype before, I found that if you really want to achieve fairly high retrieval accuracy, you need to use more techniques and do all kinds of debugging.

For example, multi-query retrieval. Its principle is: based on the user’s question, first use the large language model to generate several questions with roughly the same meaning but different wording, and then use all of those questions for retrieval. In this way, the retrieved passages will be comprehensive enough.

The retrieval in OpenGPTs uses only a relatively basic method. If you’re not satisfied with the retrieval results, you can make adjustments in the ingest document. Because retrieval performance depends on the data type. So this part really requires everyone to do secondary development based on their own situation.

OK, we’ve just introduced Chatbot and RAG. The third function, Application, can be simply understood as a combination of the first two — you can set a Prompt, choose a large language model, and add documents. On top of that, it also adds tool functionality.

There are very few ready-made tools in ChatGPT. More often, you need to rely on Function Call to implement them, because OpenAI’s goal is to continuously improve AI’s general capabilities. In OpenGPTs, search alone offers several tools:

  • General search tools include DuckDuckGO, as well as Tavily, an engine specifically optimized for large language models.
  • Vertical search tools include tools for searching papers, SEC filings, Wikipedia, press releases, and so on.

The one I use most often is paper search. To use large language model-related technologies well, you must understand the principles behind them. Reading papers is a must. No matter how hard it is, you have to force yourself to grind through them.

For example, if you want to understand Chain of Thought, OpenGPTs will go to arxiv and find the most relevant papers, including the title, author, and a summary. If you search keywords directly on arxiv, you’ll get quite a lot of results, and you’ll still have to manually filter them — it’s much better to let AI do that step.

That’s all for the basic usage of Chatbot, RAG, and Application. The real potential lies in customization, or in other words, secondary development.

OpenGPTs is like a shell: on the backend, it provides interfaces that can connect all kinds of large language models and tools; on the frontend, it provides a simple interactive interface. The LangChain team has already done all the basic work for us.

During the Spring Festival holiday, I will carefully study the project documentation and try to assemble a tool and integrate it. If successful, I’ll make another video.