{/* banner prompt: A bright editorial illustration of a wall covered in colorful rounded tag pills with words like "Golden Hour", "Rule of Thirds", "Contrapposto", one pill lifted by a hand with a floating card above it revealing a tiny glowing photograph inside, confident shapes, strong daylight tones, optimistic and clear, 16:9.

Additional instructions: make sure all the words in the image are correctly spelled */}

If you have ever built a prompt for Midjourney, Stable Diffusion, or any other text-to-image model, you have probably typed a term you only half understood. *Golden Hour* sounds nice, but is it a lighting style or a time of day? What exactly does *Rule of Thirds* do to a picture? And what on earth is *Contrapposto*?

[Tynion](/tynion), our free text-to-image prompt helper, was built to take the guesswork out of assembling prompts: click the terms you want, copy the finished prompt. But until now it had the same flaw as every prompt cheat-sheet on the internet. It gave you the **words** without showing you the **pictures**.

Tynion v2 fixes that.

## Every Term Now Explains Itself

Hover over any term in Tynion (or tap the ⓘ on mobile) and a card pops up with two things:

1. **A plain-English definition**: written for someone who has never heard the term, covering what the viewer sees and when to use it.
2. **A real example image**: generated specifically to demonstrate that one term and nothing else.

There are nearly **1,000 terms** in the new vocabulary, and every single one has a definition. Here is what that looks like in practice.

### Lighting, Demonstrated

The trick that makes the example images useful is consistency: within a group, every image uses the **same neutral base subject**, a person in plain casual clothing against a plain background, so the only thing that changes between images is the term itself.

![Studio Lighting: controlled softbox light, clean and even](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/studio-lighting.jpg)
*Studio Lighting: controlled artificial light from softboxes, shaped to flatter the subject. Clean, polished, professional.*

![Cinematic Lighting: moody directional light with dramatic falloff](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/cinematic-lighting.jpg)
*Cinematic Lighting: the same kind of subject, completely different mood: directional, warm, with deep shadow falloff.*

![Golden Hour: warm low-sun light with long soft shadows](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/golden-hour.jpg)
*Golden Hour: the hour after sunrise or before sunset. Warm, soft, low-angle light and long gentle shadows.*

![Rembrandt Lighting: the signature triangle of light on the shadowed cheek](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/rembrandt-lighting.jpg)
*Rembrandt Lighting: look closely at the shadowed cheek. That small triangle of light is the whole technique, borrowed from the painter himself.*

Once you have seen these four side by side, you will never confuse them in a prompt again.

### Composition: So *That* Is the Golden Ratio

Composition terms are the ones people bluff the most. Tynion v2 adds a whole **Composition** group (Rule of Thirds, Golden Ratio, Golden Spiral, Leading Lines, Negative Space, Frame Within a Frame, and more) each with an example image built to make the technique obvious.

![Golden Ratio: a lighthouse placed on the classical 1:1.618 proportion](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/golden-ratio.jpg)
*Golden Ratio: the subject sits slightly off-centre on the classical ~1:1.618 proportion. Balanced and harmonious without feeling rigidly centred.*

![Rule of Thirds: key elements on the third-lines of the frame](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/rule-of-thirds.jpg)
*Rule of Thirds: the frame divided into a 3×3 grid, with the key elements sitting on the lines. The simplest cure for dead-centre composition.*

### Poses, Finally With Pictures

v2 also adds a proper **Pose & Posture** group: 36 poses from classical to dynamic. This was the most requested gap in v1: pose names are vivid to artists and meaningless to everyone else.

![Contrapposto: weight on one leg, hips and shoulders counter-tilted](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/contrapposto.jpg)
*Contrapposto: weight on one leg so the hips and shoulders tilt in opposite directions, the relaxed S-curve that classical sculptors loved.*

![Power Stance: feet planted wide, shoulders squared](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/terms/power-stance.jpg)
*Power Stance: feet planted wide, shoulders squared to the camera. Instant confidence, popular in hero and fashion shots.*

## What Else Is New in v2

The visual glossary is the headline, but the whole app was rebuilt around it:

- **A much bigger vocabulary**: from ~300 terms to nearly 1,000, including new groups for **Focus & Lens** (Bokeh, 85mm Portrait Lens, Anamorphic), **Color & Palette** (Teal and Orange, Pastel, Sepia), and **Film & Medium** (Kodak Portra 400, Polaroid, CineStill 800T).
- **A data cleanup**: Golden Hour, Bokeh, and Depth of Field were misfiled as "camera angles" in v1 (guilty as charged). The camera groups are now properly split into Shot Framing, Camera Angle, and View Direction.
- **An editable final prompt**: the assembled prompt is now a real text box you can tweak by hand before copying.
- **🎲 Inspire Me**: one click picks a coherent random combination across subject, lighting, composition, framing, and style. Great for breaking a blank-page moment.

## How the Example Images Were Made

A small confession of dogfooding: every example image was generated by the same kind of pipeline Tynion helps you build prompts for. A script walks the glossary, builds a demonstration prompt per term, with a fixed base subject and one variable, and feeds it to an image model (Gemini's Imagen, in this batch). The exact prompt used for every image is saved right next to it, so if you want to know how the *Rembrandt Lighting* demo was made, the recipe is [a click away](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/apps/tynion/prompts/rembrandt-lighting.md).

Generating nearly a thousand demonstration images taught us a few things about rate limits and retry logic, but that is a story for another post.

## Try It

Tynion is free and runs entirely in your browser, with no signup and nothing stored: **[tyolab.com/tynion](/tynion)**

Hover around. The glossary is the kind of thing that is hard to stop playing with once you start, and if you spot a term that deserves a better explanation (or a missing term entirely), the feedback link at the bottom of the page goes straight to us.


8536cff19213bddfd0ac3e8d618b7c1ea98175fad9986c165736ab10daffa7a0

Tynion v2 turns a tag-picking prompt builder into a visual glossary for AI image generation. Every lighting style, camera angle, composition rule, and pose now ships with a definition and an AI-generated example image, same base subject with one variable changed, so you can see what a term does before you put it in your prompt.

Tynion, our text-to-image prompt helper, just got its biggest update yet: nearly 1,000 prompt terms, and every one of them now explains itself. Hover over any term (Golden Hour, Rule of Thirds, Contrapposto) and a card pops up with a plain-English definition and a real example image showing exactly what that term does to a picture.

Tynion v2: See What Every Prompt Term Looks Like

{/* banner prompt: Here is a creative and engaging prompt for a banner image, based on the blog post:

**Prompt:**

A cinematic, photorealistic digital artwork of a glowing, intricate cryptographic key made of shimmering circuit board patterns and flowing data streams. The key is poised to unlock a large, stylized padlock representing an encrypted database. The WeChat logo is subtly etched onto the face of the lock. The background is a dark, futuristic digital landscape with faint binary code and abstract network lines. The scene is lit by the key's vibrant cyan and green neon glow, creating high contrast and dramatic shadows. Sleek, modern, technology-themed, highly detailed. --ar 16:9

Additional instructions: try not to use dark / blackground, not to use any word "wechat", use Vendetta mask style hacker sitting infront of a computer */}

WeChat stores your message history in a local SQLite database encrypted with [SQLCipher](https://www.zetetic.net/sqlcipher/). To read your own messages with any third-party tool, including backup utilities or search apps, you first need the encryption key that WeChat uses to lock that database.

Getting that key used to mean running commands in a terminal, attaching debuggers, or following fragile step-by-step guides that broke with every WeChat update. **WetraceTool** wraps the underlying [wetrace](https://github.com/afumu/wetrace) hook into a simple four-step wizard. You click through the steps, log in to WeChat when prompted, and the key appears on screen ready to copy.

## What you need

- Windows 10 or 11 (64-bit)
- WeChat (国际版) or Weixin (微信) installed
- WetraceTool: download the latest `WetraceTool-Setup-*.exe` installer from [here](https://github.com/e-tang/wetrace_wrapper/releases/tag/v1.0.0).

## Step 0: Run the installer

Double-click the installer and follow the prompts. After the installation, search up "WetraceTool", the run it. Because WetraceTool needs to attach to the WeChat process, Windows will show a **User Account Control** dialog asking for elevated permissions. Click **Yes** to continue.

![Windows UAC prompt asking permission to run WetraceTool.exe](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/a-wetrace-wrapper-for-easy-wechat-key-extraction/2026-04-27-16-13-29.png)

This is expected; the tool cannot capture the key without administrator-level access to the running WeChat process.

## Step 1: Start WeChat

Once WetraceTool opens you will see the four-step wizard on the left and the current step's instructions on the right.

![WetraceTool step 1: Start WeChat, showing Launch WeChat button and "Waiting for WeChat to start" status pill](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/a-wetrace-wrapper-for-easy-wechat-key-extraction/2026-04-27-16-14-39.png)

Click **Launch WeChat** to start WeChat automatically, or just open WeChat yourself; the app polls for it in the background and will advance to the next step the moment it detects WeChat is running.

## Step 2: Get to the WeChat login screen

For the key capture to work, WeChat must be sitting at the login screen (showing a QR code or an account avatar with a "Log in" button) at the moment you sign in. If you are already logged in, you need to log out first.

![WetraceTool step 2: Log out of WeChat, with numbered instructions and a Continue button](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/a-wetrace-wrapper-for-easy-wechat-key-extraction/2026-04-27-16-15-24.png)

The app gives you the exact steps:

1. Click the **profile / avatar icon** in the bottom-left corner of WeChat
2. Go to **Settings → My Account → Log out**
3. Confirm the log out

Once you can see the QR code or the login button in WeChat, click **I can see the login screen — Continue ✓** in WetraceTool.

## Step 3: Extract the key

This is the active capture step. WetraceTool starts the background hook service and then waits for you to log in to WeChat. You have **60 seconds** from the moment you click Start.

![WetraceTool step 3: Extract Encryption Key, showing a 00:41 countdown timer and a "Start — I'm ready to log in" button](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/a-wetrace-wrapper-for-easy-wechat-key-extraction/2026-04-27-16-40-48.png)

When the **Start — I'm ready to log in** button becomes active (it will briefly show "Starting background service…" while the hook initialises), click it and then immediately switch to WeChat and log in. WeChat may reopen a login window; that is normal and expected. Just sign in as you normally would; the key is captured automatically the instant WeChat unlocks its database.

> **Tip:** Have WeChat's QR code scaner (Discover -> Scan) ready on your phone before clicking Start so you don't lose time.

## Step 4: Copy your key

If the capture succeeded, the wizard advances to the final screen showing your encryption key and, where it can be detected automatically, the path to your WeChat message database.

![WetraceTool step 4: Key Extracted, showing a redacted encryption key field with a "Copy Key" button and a database path field with a "Copy" button](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/a-wetrace-wrapper-for-easy-wechat-key-extraction/2026-04-27-16-45-01.png)

Click **Copy Key** to copy the encryption key to your clipboard. If the database path was detected, you can copy that too with the **Copy** button beneath it. Both values are what you will need to open your WeChat database with a tool like `decrypt_sync` or any SQLCipher-aware client.

You can close WetraceTool once you have copied what you need.

## Troubleshooting

**Timer runs out with no key captured**
Make sure you log in to WeChat *after* clicking Start, not before. The hook only listens from the moment you click Start.

**"Starting background service…" button never becomes active**
WetraceTool needs elevated permissions to attach to the WeChat process. Close the app, right-click the shortcut, and choose **Run as administrator**.

**WeChat is not detected automatically**
Open Task Manager and check whether `Weixin.exe` or `WeChat.exe` is listed under running processes. If neither appears, WeChat may not have launched correctly, so try starting it manually.

**Key extraction fails with a connection error**
The background hook service failed to start or was blocked. Close WetraceTool, reopen it as Administrator, and work through the steps again from the beginning.


a4d854543cb4441b91acb037f512a8b9db028f9b975e84005a482edc3cc256f4

A step-by-step guide to using WetraceTool to extract your WeChat database encryption key on Windows, so you can read your own message history with tools like decrypt_sync.

WetraceTool is a small Windows utility that walks you through extracting your WeChat SQLCipher database encryption key in four guided steps, with no command line required.

How to Extract Your WeChat Encryption Key with WetraceTool


# Building an AI Knowledge Base: Using tyo-crawler to Convert Evernote Notes into Markdown


In the age of AI, having a well-structured and easily accessible knowledge base is crucial. Large Language Models (LLMs) and Retrieval-Augmented Generation (RAG) systems are revolutionizing how we interact with information. However, the effectiveness of these systems heavily relies on the quality and format of the data they access. Many of us have accumulated vast amounts of information in note-taking applications like Evernote. While Evernote is great for personal organization, it's not inherently designed for seamless integration with AI systems.

This is where the need for a robust knowledge base in a format like Markdown becomes apparent. Markdown's simplicity and versatility make it an ideal format for AI consumption. In this article, we'll explore how to transform your Evernote notes into a structured Markdown knowledge base using `tyo-crawler`, a powerful open-source web crawler. This process will prepare your data for integration with various open-source RAG tools, enhancing the capabilities of your AI applications.

## The Power of RAG and the Need for Structured Data

Retrieval-Augmented Generation (RAG) is a game-changer in the AI landscape. It enhances LLMs by allowing them to access and incorporate external knowledge, leading to more accurate, relevant, and grounded responses. As we discussed in our previous post, ["Building a Retrieval-Augmented Generation System Using Open-Source Tools"](/blog/2025/03/14-building-a-retrieval-augmented-generation-system-using-open-source-tools/), open-source tools like **Open Web UI**, **Verba**, **Onyx**, **RagFlow**, and others provide robust frameworks for building RAG systems.

However, these tools are only as good as the data they consume.  RAG systems thrive on structured, easily parsable data. While Evernote is excellent for capturing and organizing notes, its proprietary format isn't directly compatible with most RAG tools. This is where converting your Evernote notes to Markdown becomes essential.

## Why Markdown?

Markdown is a lightweight markup language that's easy to read and write. Its simplicity makes it ideal for:

*   **AI Consumption:** RAG systems can easily parse and understand Markdown's structure.
*   **Version Control:** Markdown files can be tracked using version control systems like Git.
*   **Interoperability:** Markdown is widely supported across various platforms and tools.
*   **Flexibility:** It can be easily converted to other formats like HTML, PDF, etc.

## Introducing tyo-crawler: Your Evernote-to-Markdown Bridge

`tyo-crawler` is a versatile, open-source web crawler designed for efficient data extraction and transformation. As detailed in our previous articles, ["A Deep Dive into the tyo-crawler Web Crawler"](/blog/2025/03/27-a-deep-dive-into-the-tyo-crawler-web-crawler) and ["How to Scrape Twitter (X) Data Using tyo-crawler"](/blog/2025/04/13-how-to-scrape-twitter-x-data-using-tyo-crawler), `tyo-crawler` excels at navigating complex websites, extracting specific data, and converting it into structured formats.

While `tyo-crawler` is primarily used for web scraping, its powerful parsing and transformation capabilities make it an excellent tool for converting Evernote notes to Markdown. Here's how we can leverage it:

Please refer to [this post](/blog/2025/03/27-a-deep-dive-into-the-tyo-crawler-web-crawler) mentioned before for the installation and usage instructions of `tyo-crawler`. Similar to the [Twitter scraping example](/blog/2025/04/13-how-to-scrape-twitter-x-data-using-tyo-crawler), we will use an `evernote` processor and a specific set of actions to extract data from Evernote and convert it into Markdown format.

### Actions File for Evernote
The `tyo-crawler` uses an `actions.json` file to define the actions it should perform during the crawling process. This file specifies how to interact with the web pages, including logging in, navigating, and extracting data. The actions file is crucial for customizing the crawling process to suit your needs.

An example of the actions file (`examples/evernote.example.json`) for crawling EverNote notes is located in the `tyo-crawler` directory under the `examples` folder. You don't need to modify this file, but you can refer to it for understanding how the crawling process works if you want. 

### Preparing Evernote Links
Assuming you have a list of Evernote links, you can create a file named `evernote_links.txt` containing the URLs of your notes. Each link should be on a new line. For example:

```plaintext
https://www.evernote.com/shard/s123/nl/1234567890/abcd1234-5678-90ef-ghij-klmnopqrstuv
https://www.evernote.com/shard/s123/nl/1234567890/wxyz9876-5432-10ab-cdef-ghijklmnopqr
```
### Running tyo-crawler

To run `tyo-crawler` with the Evernote processor, use the following command:

```bash
tyo-crawler --browser-wait-time 8000 --actions-file ./examples/evernote.example.json --with-cookies true  --processor evernote  --links-file ./evernote_links.txt 
```

All converted Markdown files will be saved in the `output` directory.

### Example Output

The output will be a set of folders, each corresponding to an Evernote note. The folder name will be named based on the note titles and will contain the note's content (`index.md`), including text, and links to images (saved under `./[NOTE_TITLE]/resources/`).
For example, a note titled "My First Note" will be saved as `output/My_First_Note` in the `output` directory. The content will be structured in Markdown format, making it easy to read and integrate with other tools.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/04/building-an-ai-knowledge-base-using-tyo-crawler-to-convert-evernote-notes-into-markdown/output_example1.png)

## Organizing Your Markdown Knowledge Base

After the conversion, you'll have a collection of Markdown files. It's a good practice to organize them into folders based on topics or notebooks. This structure will make it easier to manage and use your knowledge base with RAG tools.

## Integrating with RAG Tools

Now that your Evernote notes are in Markdown, you can easily integrate them with open-source RAG tools. Here's a brief overview of how you might do this with some of the tools we discussed earlier:

*   **Open Web UI:** Upload your Markdown files to Open Web UI's knowledge library. The system will index them, allowing you to retrieve relevant information during conversations.
*   **Verba:** Use Verba's document ingestion feature to add your Markdown files. Verba will create embeddings and enable citation-based answers.
*   **Onyx:** Connect Onyx to the folder containing your Markdown files. Onyx will automatically index the content and make it searchable.
* **RagFlow**: Use RagFlow to ingest your markdown files, and then you can start to ask questions.
* **RAG Web UI**: You can upload your markdown files to create a knowledge base, and then start to chat with it.
* **MaxKB**: You can upload your markdown files to create a knowledge base, and then start to chat with it.

## Conclusion

Building an AI knowledge base is a crucial step in leveraging the power of RAG systems. By converting your Evernote notes to Markdown using `tyo-crawler`, you create a structured, AI-ready data source. This process not only enhances the capabilities of your RAG applications but also provides a more organized and accessible way to manage your personal or organizational knowledge.

`tyo-crawler`'s flexibility and power make it an invaluable tool for data transformation tasks like this. As AI continues to evolve, having a well-structured knowledge base will become increasingly important. By taking the time to convert your notes to Markdown, you're setting yourself up for success in the AI-driven future.


<ContactFooter />


a90d6f4c295273ba7877ed9a21e8f6fd44e5a34047e2966cbed069ffff701f25

This guide demonstrates how to leverage tyo-crawler to convert Evernote notes into Markdown, creating a well-organized knowledge base that can be used with open-source RAG tools for enhanced AI applications.

Learn how to transform your Evernote notes into a structured Markdown knowledge base using tyo-crawler, making them ready for integration with Retrieval-Augmented Generation (RAG) systems.

Building an AI Knowledge Base: Using tyo-crawler to Convert Evernote Notes into Markdown


# Building a Retrieval-Augmented Generation System Using Open-Source Tools

## Introduction

Retrieval-Augmented Generation (RAG) is a powerful AI paradigm that enhances large language models (LLMs) by incorporating external knowledge retrieved from structured or unstructured data sources. This approach improves factual accuracy, reduces hallucinations, and provides users with more grounded responses. By leveraging RAG, organizations can build AI-powered assistants capable of answering queries based on proprietary or publicly available knowledge bases.

The open-source ecosystem offers a range of tools to implement RAG-based applications. These tools provide document ingestion, vector storage, retrieval mechanisms, and chat interfaces that seamlessly integrate with LLMs. In this guide, we will explore some of the most prominent open-source RAG tools, including **Open Web UI**, **Verba**, **Onyx**, **LobeChat**, **RagFlow**, **RAG Web UI**, **Kotaemon**, and **Cognita**. Each tool comes with distinct features and capabilities that cater to different use cases, ranging from personal knowledge management to enterprise-scale AI solutions. However, most of these tools are still under heavy development; the learning curve could be an issue due to different designs, and you may need lots of tuning and configuration to achieve what they claim.

## Open-Source Tools for Building a RAG System

### Open Web UI
**Description**: Open Web UI is an extensible, self-hosted AI chat platform that supports RAG-based retrieval. It allows users to upload documents into a persistent knowledge library, retrieve relevant content, and inject context into conversations. It supports multiple LLM backends, including local and cloud-based models.

**Supported Documents**: Markdown, PDF, web search results, and YouTube transcripts.

**GitHub Repository**: [open-webui/open-webui](https://github.com/open-webui/open-webui)

**Installation**:

```bash
# probably it would be best to create a new virtual environment before installing
pip install open-webui
```

**Usage:**  

```bash
open-webui serve
```
To start the App: [http://localhost:8080](http://localhost:8080)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/exploring-the-best-free-and-open-source-chat-uis-for-llms/openwebui.png)


**Open Web UI** is primarily designed as a chat interface for interacting with various LLM models. In addition to this, it includes a powerful [RAG feature](https://docs.openwebui.com/features/rag/) that allows integration of external knowledge sources. You can follow the detailed [RAG tutorial](https://docs.openwebui.com/tutorials/tips/rag-tutorial/) to learn how to set up and utilize this feature effectively.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/openwebui1.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/openwebui2.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/openwebui3.png)


### Verba
**Description**: Verba is an intuitive, open-source RAG chatbot that simplifies knowledge retrieval. Developed by Weaviate, it provides a web UI for document ingestion, citation-based answers, and autosuggestions.

**Supported Documents**: Plain text, Markdown, PDF, and GitHub repositories.

**GitHub Repository**: [weaviate/Verba](https://github.com/weaviate/Verba)

**Installation:**

```bash
git clone https://github.com/weaviate/Verba.git
```

**Usage:**
```bash
cd Verba
docker compose up --build
## if you are plan to use Verba constantly, you can run `docker compose up -d`, so the server will run in the background
```

To start the App: [http://0.0.0.0:8000/](http://0.0.0.0:8000/)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/verba.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/verba2.png)

One limitation I’ve noticed is that Verba doesn’t currently support multiple document sets or knowledge bases. This can be restrictive for more complex applications where isolated or domain-specific document contexts are needed, such as supporting multiple clients, handling different projects, or toggling between datasets during testing. Having the ability to define and switch between separate document sets would greatly improve scalability, modularity, and overall usability for real-world scenarios.

### Onyx (formerly Danswer)
**Description**: Onyx is an enterprise-ready GenAI platform that integrates with over 40 data sources. It enables secure knowledge retrieval with access control, custom AI agents, and robust document processing.

**Supported Documents**: Google Drive, Dropbox, SharePoint, Confluence, emails, and GitHub repositories.

**GitHub Repository**: [onyx-dot-app/onyx](https://github.com/onyx-dot-app/onyx)


**Installation:**

```bash
git clone https://github.com/onyx-dot-app/onyx.git
cd onyx/deployment/docker_compose
cp env.prod.template .env
# You may need to change the AUTH_TYPE in .env file to basic or other authentication method you like 
# if you don't want to use Google OAuth2.0
# AUTH_TYPE=basic
cp env.nginx.template .env.nginx
ln -s docker-compose.prod.yml docker-compose.yml
```

**Usage:**
```bash
cd onyx/deployment/docker_compose
docker compose up
## if you are plan to use Onyx constantly, you can run `docker compose up -d`, so the server will run in the background
```

You may need extra steps to setup Google oauth2.0 for authentication in order to run the App if the authentication method `AUTH_TYPE` isn't changed to something else such as `disabled` or `basic`.

To start the App: [http://localhost](http://localhost)


![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/onyx1.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/onyx2.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/onyx3.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/onyx4.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/onyx5.png)

Onyx is a powerful RAG tool that offers a wide range of features for knowledge management and retrieval. It supports multiple data sources, making it suitable for enterprise applications. However, the setup process can be complex, and users may need to invest time in configuring the platform to meet their specific requirements. 

### LobeChat
**Description**: LobeChat is a modern AI chat framework that integrates RAG for personalized knowledge management. It supports multiple AI model providers and multimodal content.

**Supported Documents**: Text files, images, audio, and video files.

**GitHub Repository**: [lobehub/lobe-chat](https://github.com/lobehub/lobe-chat)

**Installation**

```bash
mkdir lobe-chat-db && cd lobe-chat-db
bash <(curl -fsSL https://lobe.li/setup.sh) -l en
## Then you follow the prompt to setup the app
```

**Usage**

```bash
docker compose up
```

To start the App: [http://localhost:3210](http://localhost:3210)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/exploring-the-best-free-and-open-source-chat-uis-for-llms/lobechat.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/exploring-the-best-free-and-open-source-chat-uis-for-llms/lobechat2.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/exploring-the-best-free-and-open-source-chat-uis-for-llms/lobechat3.png)

Unfortunately, I wasn’t able to use the RAG feature in LobeChat. When initiating a chat with an attached knowledge base, an OpenAI API key error appeared in the background, despite the fact that I was only using the local Ollama model.

### RagFlow
**Description**: RagFlow specializes in deep document understanding for accurate Q&A. It supports intelligent chunking, advanced parsing, and document visualization to enhance retrieval quality.

**Supported Documents**: Microsoft Office files, Images, PDFs, structured data, and web pages.

**GitHub Repository**: [infiniflow/ragflow](https://github.com/infiniflow/ragflow)

**Installation**:

```bash
git clone https://github.com/infiniflow/ragflow.git
```

**Usage**:

```bash
cd ragflow
cd docker
docker compose up
```

To start the App: [http://localhost](http://localhost)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragflow.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragflow2.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragflow4.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragflow5.png)


### RAG Web UI
**Description**: RAG Web UI is an interactive chatbot system with support for various document formats. It offers a full-stack RAG implementation, making it easy to deploy knowledge-based assistants.

**Supported Documents**: PDF, Word, Markdown, and plain text.

**GitHub Repository**: [rag-web-ui/rag-web-ui](https://github.com/rag-web-ui/rag-web-ui)

**Installation**:
```bash
git clone https://github.com/rag-web-ui/rag-web-ui.git
cp .env.example .env
# Remember to edit the .env file to add your own open api key to OPENAI_API_KEY
```


**Usage**:
```bash
cd rag-web-ui
docker compose up --build
```

To start the App: [http://localhost](http://localhost)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragwebui.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/ragwebui2.png)


One issue is that after creating a knowledge base, you can't change the name anymore. Also you won't be able to change the knowledge base for the chat. In order to use a different knowledge base, you need to create a new one.

### Kotaemon
**Description**: Kotaemon is a clean and customizable RAG web UI that supports multi-user document ingestion. It includes hybrid search, citation-based answers, and visual annotations.

**Supported Documents**: PDF, HTML, MHTML, and Excel. Extended support via Unstructured integration.

**GitHub Repository**: [Cinnamon/kotaemon](https://github.com/Cinnamon/kotaemon)

**Installation**:

It would be best if you had Docker and Docker Compose installed on your machine. Then run the following commands:

```bash
mkdir Kotaemon
cd Kotaemon
git clone https://github.com/Cinnamon/kotaemon.git
mkdir docker-compose
cp code/.env.example docker-compose/.env
cd docker-compose
# Create a docker-compose.yml file
vim docker-compose.yml
```

Put the following content into docker-compose.yml
```yaml
version: '3.8'

services:
  kotaemon:
    image: ghcr.io/cinnamon/kotaemon:main-lite
    environment:
      - GRADIO_SERVER_NAME=0.0.0.0
      - GRADIO_SERVER_PORT=7860
    ports:
      - "7860:7860"
    volumes:
      - ./ktem_app_data:/app/ktem_app_data
    stdin_open: true
    tty: truek
    restart: unless-stopped

```

**Usage**:

```bash
cd Kotaemon/docker-compose
docker-compose up
```

Then start the App: [http://localhost:7860](http://localhost:7860), and use 'admin' as the username and 'admin' as the password to login.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/kotaemon.png)

To be honest, Kotaemon is not particularly user-friendly, and it's not very easy to use. It is quite difficult to set up and configure properly. Initially I couldn't get it to work, but after some tweaking, I managed to get it to work. Rather than picking what model you want to use, you have to set a default model in the Resources (aka settings) tab, which is not very intuitive.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/kotaemon2.png)

### Cognita
**Description**: Cognita is a modular RAG framework designed for production-ready AI applications. It offers structured indexing, API-based retrieval, and multimodal support.

**Supported Documents**: PDFs, web pages, GitHub repositories, audio, video, and images.

**GitHub Repository**: [truefoundry/cognita](https://github.com/truefoundry/cognita)

**Installation**:

The easiest way to install Cognita is via Docker:

```bash
git clone https://github.com/truefoundry/cognita.git
cd cognita
cp models_config.sample.yaml models_config.yaml

```

**Usage**:

```bash
cd cognita
docker-compose --env-file compose.env up
```

Start to App: [http://localhost:5001](http://localhost:5001)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/coginta.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/coginta2.png)

Obvoiusly, Cognita does't really work out of the box, you need to configure it properly, and it's not very straightforward to do so.

### MaxKB
**Description**: MaxKB (Max Knowledge Base) is an open-source, ready-to-use RAG chatbot platform built on large language models (LLMs). It allows users to create a Q&A knowledge base by uploading documents or crawling web pages, with automatic text splitting and vector embedding to enable retrieval-augmented generation. MaxKB is model-agnostic, supporting various private and public LLMs (e.g., DeepSeek, Llama, Qwen, OpenAI’s GPT series, Claude, etc.). It also provides a workflow engine and integration features for orchestrating complex AI processes within existing systems.

**Supported Documents**: Markdown, plain text (TXT), Word documents (DOCX), PDFs, HTML, Excel spreadsheets (XLS/XLSX), and CSV files.

**GitHub Repository**: [MaxKB on GitHub](https://github.com/1Panel-dev/MaxKB)

**Installation**:

```bash
# git clone https://github.com/1Panel-dev/MaxKB.git
mkdir MaxKB
cd MaxKB
vim docker-compose.yml
# or use your favorite editor, e.g., nano, code, etc.
```

Put the following content into docker-compose.yml
```yaml
version: '3.8'

services:
  maxkb:
    image: 1panel/maxkb
    container_name: maxkb
    ports:
      - "8080:8080"
    volumes:
      - ~/.maxkb:/var/lib/postgresql/data
      - ~/.python-packages:/opt/maxkb/app/sandbox/python-packages
    restart: unless-stopped
```

**Usage**:

```bash
cd MaxKB
docker-compose up
```

Then start the App: [http://localhost:8080](http://localhost:8080)

Login with the default credentials: `admin` and `MaxKB@123..`.


![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/maxdb2.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/maxdb3.png)
![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/03/building-a-retrieval-augmented-generation-system-using-open-source-tools/maxdb4.png)

Overall I would say the process of setting up models was not very pleasant but after that, it was quite easy to use.


## Conclusion

Building a Retrieval-Augmented Generation system requires careful selection of tools based on the specific needs of an application. Open-source RAG frameworks provide a cost-effective and flexible way to integrate external knowledge retrieval with LLM-based interactions. Whether for personal knowledge assistants or enterprise AI solutions, tools like **Open Web UI**, **Verba**, **Onyx**, **Cognita**, **RagFlow** and others offer a robust foundation for implementing RAG workflows. By leveraging these tools, developers can create intelligent systems that enhance factual accuracy and contextual relevance in AI-generated responses.

Personally, I recommend both **Onyx** and **RagFlow** for their comprehensive feature sets. In particular, **Onyx** stands out with its wide range of connectors, making it easy to integrate documents from various sources and build your own knowledge base. However, each tool has its own strengths and weaknesses, so it is essential to evaluate them based on your specific requirements. With the right combination of tools and expertise, you can build a powerful RAG system that transforms how users interact with AI-powered assistants.


<ContactFooter />




396ad025a8659f598b33a205f5c0e1d307a8c5c1ed9b6684a1c9f9f2f523de92

Open-source tools provide a range of features for building a Retrieval-Augmented Generation (RAG) system, enhancing large language models (LLMs) with external knowledge retrieval. In this post, we explore some of the most prominent open-source tools for implementing RAG-based applications, including Open Web UI, Verba, Onyx, LobeChat, RagFlow, RAG Web UI, Kotaemon, and Cognita.

In this post, we explore some of the most prominent open-source tools for building a Retrieval-Augmented Generation (RAG) system, including Open Web UI, Verba, Onyx, LobeChat, RagFlow, RAG Web UI, Kotaemon, and Cognita.

Building a Retrieval-Augmented Generation System Using Open-Source Tools


# Empowering Your Ideas with AI: Exploring New LLM Chat Tools

In the dynamic landscape of artificial intelligence, Large Language Models (LLMs) have revolutionized how we generate ideas, create content, and interact with technology. These advanced AI chat tools empower users to transform concepts into reality with unprecedented ease and efficiency. This article explores a couple of new open source LLM chat tools, **Cherry Studio** and **ChatBox**, which are not covered in this [post](/blog/2025/28-exploring-the-best-free-and-open-source-chat-uis-for-llms/), highlighting their unique features and LLM integrations. [ChatWise](https://www.chatwise.app/) seems to be an interesting AI Chat tool too, but it is not open source and only available on Windows and Mac so it wont be  covered in this post.

## **Cherry Studio**

[Cherry Studio](https://github.com/CherryHQ/cherry-studio) is a desktop client that supports multiple LLM providers (OpenAI, Gemini, Anthropic, DeepSeek, SiliconFLow, O3, AiHubMix, ocoolAI, Baidu Cloud, Ollama, LM Studio, etc.), offering users the flexibility to choose and switch between different AI models as needed. It includes built-in templates for **Assistants** and **Agents**, though many of the preset system prompts are in Chinese. Fortunately, it also offers a translation tool, allowing you to generate translations across different languages using AI models. This flexibility enables experimentation and optimization, ensuring the chosen model aligns with specific user needs. Cherry Studio’s interface simplifies AI model deployment and management, making it accessible even to users without extensive technical expertise. Additionally, its support for multiple LLM providers makes it a valuable tool for those exploring AI solutions.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/empowering-your-ideas-with-ai-chat-a-comparative-guide-to-llm-integration-tools/cherrystudio.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/empowering-your-ideas-with-ai-chat-a-comparative-guide-to-llm-integration-tools/cherrystudio-models.png)


## **ChatBox**

[ChatBox](https://github.com/Bin-Huang/chatbox) is another open-source LLM chat tool that provides a user-friendly interface for interacting with AI models. Its intuitive design simplifies the process of generating text, enabling users to leverage the power of AI without complex setup or configuration. ChatBox's integration with popular LLM providers enhances its functionality, allowing users to access cutting-edge AI capabilities seamlessly. By combining ease of use with advanced AI features, ChatBox offers a compelling solution for users seeking to harness the potential of LLM technology.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/empowering-your-ideas-with-ai-chat-a-comparative-guide-to-llm-integration-tools/chatbox.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/02/empowering-your-ideas-with-ai-chat-a-comparative-guide-to-llm-integration-tools/chatbox-models.png)



<ContactFooter />

4a543e274d4a5b2e5b23987c236501ac51179156b7d1ac2fbeed04924448ff86

In this post, we explore two new open-source LLM chat tools: Cherry Studio and ChatBox, highlighting their unique features and LLM integrations.

Tag: Tools

Tag: Tools

Tynion v2: See What Every Prompt Term Looks Like

How to Extract Your WeChat Encryption Key with WetraceTool

Building an AI Knowledge Base: Using tyo-crawler to Convert Evernote Notes into Markdown

Building a Retrieval-Augmented Generation System Using Open-Source Tools

Empowering Your Ideas with AI: Exploring New LLM Chat Tools