Yuxi-Know is a free and open-source platform built on LangGraph, Vue.js, FastAPI, and LightRAG that enables the creation of agents with retrieval-augmented generation (RAG) knowledge bases and knowledge graphs. Its latest beta version, v0.4.0-beta (released in December 2025), adds file uploads, multimodal image support, file generation mind maps, evaluation tools, dark mode, and optimized graph visualization capabilities. The platform helps users quickly build and deploy customized AI bodies for Q&A, analysis, and retrieval scenarios without developing from scratch, saving significant development time and effort.
In the past two years, large language models have almost solved the problem of “language” itself.
But a more realistic question arises:
If we want to do not ChatBot, but “Agent”, where do we start?
- Do agents need to have memory?
- Do you want to be able to call the tool?
- Do you want to have long-term goals?
- How to avoid just being a “shell GPT”?
Yuxi-Know on GitHub is an experimental solution around “how to build agents”.
It’s not a finished product, but more like a sketch of the Agent architecture.
The boundary of “building agents”
In the context of Yuxi-Know, agents ≠ chatbots.
If you summarize the author’s thoughts in one sentence:
Agent = LLM + memory system + behavioral ability + internal state management
This differs from many off-the-shelf solutions in that they are:
- ❌ Not a “Prompt → Answer”
- ❌ Not “Task List → Automatically”
- ✅ It is a system that persists, accumulates experience, and can call on external capabilities
What Yuxi-Know is trying to solve is the agent’s “system-layer problem” rather than prompt tricks.
Yuxi-Know’s agent solution: overall architecture disassembly
If you look at it from the perspective of “building agents”, the structure of this project is very clear and can be broken down into 5 core levels.
Agent Core: Not a Model, but a “Dispatch Hub”
In Yuxi-Know, LLMs are not the protagonists.
The real protagonist is the Agent control layer, which is responsible for:
- Receive user input
- Decision:
- Direct reply?
- Memory check?
- Check the knowledge base?
- Calling tools?
- Manage multiple rounds of context and behavior sequences
This step is critical:
The model is just the “capability module” that is called, not the system itself.
Memory: This is a watershed moment for agents and ChatBots
Yuxi-Know places a lot of emphasis on memory systems, and not simply conversational history.
Its memory design ideas include:
- Short-term memory: the context of the current session
- Long-term memory: historical events, fragments of knowledge (vectorized storage)
- Retrievable Memories: Trigger “Recall” with embedding + vector search
This step solves an essential problem:
Can agents “remember their past selves”?
Without this layer, the so-called agent can easily degenerate into a one-time conversation tool.
Knowledge: The “cognitive expander” of the outside world
In the Agent architecture, there is a very important principle:
Don’t let the model “hard back the world”, but learn to “check the world”.
Yuxi-Know’s knowledge system takes on this role:
- Document vectorization
- On-premises / external knowledge base
- After retrieving, it is handed over to the Agent to judge whether to use it
This allows agents to have scalable knowledge boundaries instead of being locked into model training data.
Tools: Enabling agents to truly “act”
This is one layer where Yuxi-Know explicitly aligns the Agent concept.
The tool system allows agents to:
- Search for information
- Call the API
- Execute the script
- Operational Files (in theory)
That is, the system is designed with:
Migrated interfaces from Linguistic Intelligence → Behavioral Intelligence
This step is where many agent projects get stuck, and Yuxi-Know is at least structurally clear.
UI: Deliberately weakened, but not unimportant
Yuxi-Know’s frontend is based on ChatGPT-Next-Web, but you’ll find:
- UI is not the focus of the project
- It’s just a debugging and interaction portal
This is the attitude that a mature agent project should have:
The agent is a system, not an interface.
What is the core value of the solution?
If you only look at the features, Yuxi-Know is not “amazing” now.
But from the perspective of “building an agent solution”, it has three very important values.
Clearly distinguishing between “model” and “agent”
The problem with many projects is:
- Think of Agent as a “GPT that automatically says a few more words”
- Or as a “prompt with tools”
And Yuxi-Know is very clear:
Models are replaceable parts, and agents are systems.
A landable Agent minimum structure is given
It pretty much gives an Agent MVP checklist:
- Is there an Agent control layer?
- Do you have long-term memory?
- Can I call an external tool?
- Can it continue to operate?
You can use it as a reference template for the Agent schema.
Github：https://github.com/xerrors/Yuxi-Know
Tubing: