Lian MCP Llm Agent

🚀 Lian-MCP-LLM Agent System

A local multi-expert intelligent agent scheduling system + tool call protocol management + extensible knowledge base

By - Lian - 2025

🚀 Quick Start

The Lian-MCP-LLM Agent System is a comprehensive solution that integrates multi-expert intelligent agent scheduling, tool call protocol management, and an extensible knowledge base. This README provides an overview of the system's core components, development progress, and usage instructions.

✨ Features

🌟 Core of the Project

| Top Layer: Multi-Expert Collaboration and Scheduling (Highlight of the Thesis)

• Auto-spawn agents: The administrator LLM automatically generates n experts based on the task. Each expert has a role label (Role) and a lifecycle (create → run → exit).
• Responsibilities of the administrator LLM: The administrator is not an executor but a scheduling center. It receives user input, decomposes tasks, schedules different experts, routes messages, controls which experts are killed or created, and finally converges the outputs of all experts to return the result.
• Communication protocol between experts (Agent → Agent, Agent → Admin): A clear routing and management rule is required. For example:
  • Request types: Inquiry, collaboration, evaluation
  • Data format: JSON schema
  • ID identification: session_id, agent_id
  • The administrator decides the actions for each iteration.

📦 Installation

The project is still under development. Some components are already completed, while others are in progress. Please refer to the following development progress section for more details.

💻 Usage Examples

Development Progress

💾 (1) Database Layer: LianORM --done--

A self-developed lightweight ORM system with a hierarchical architecture design.

• Core Architecture:
  • Schema: An FSM-based SQL parser that extracts metadata without relying on the database.
  • Mapper: An intelligent type conversion system that supports automatic mapping of JSON/Vector.
  • Repository: The specific implementation of CRUD operations for business objects.
  • Database: Encapsulates the connection pool and atomic operation client.
  • ORM: The unified entry and resource management.
• 📚 Documentation Center:
  • LianORM Module Usage Documentation
  • Data Models (Models) | Metadata (Schema) | Type Mapping (Mapper)
  • Repository Layer (Repository) | Database Layer (Database) | Top-level Interface (ORM)
  • Configuration Instructions (Config)

🔌 (2) Tool Layer: MCP Server --done--

A tool aggregation server based on FastAPI that provides a unified interface for tool discovery and invocation.

• Core Functions:
  • Tool Management: Automatically discovers and loads tool modules, supporting hot reloading.
  • RESTful API: Provides a complete set of interfaces for tool query and invocation.
  • Metadata Extraction: Automatically extracts function signatures, parameter types, and documentation from tool code.
  • Tool Classification:
    • file_tool: File read/write, copy, move, delete, etc.
    • dir_tool: Directory creation, listing, tree display, statistical information.
    • web_tool: HTTP requests, web content extraction, HTML/JSON parsing.
• Startup Modes:
  • Production Mode:

uv run python ./main.py server
# Customize the address and port
uv run python ./main.py server --host 127.0.0.1 --port 8888

• Documentation: MCP Server API Documentation (Click to jump)

🤖 (3) Interaction Layer: LLM Client --done-- (Waiting for Refactoring)

An LLM client encapsulation that supports multiple model providers and tool invocation (currently tested with deepseek-chat).

• Core Functions:
  • Tool Invocation: Automatically integrates MCP Server tools, supporting function calling.
  • Continuous Invocation: Supports multi-round continuous invocation of tools until the LLM returns TOOL_CALL_END.
  • Dialogue Management: Complete dialogue context management and history recording.
  • Dual Interfaces: Terminal interactive interface + Streamlit Web UI.
• Usage Modes:
  • Terminal Client (Interactive Command Line):

uv run python ./main.py client

• Web UI (Streamlit Web Interface):

uv run python ./main.py web

• Web UI Features:
  • 📱 Left-right split layout: Dialogue on the left, real-time logs on the right.
  • 🎨 Beautiful message bubble styles.
  • 📊 Visualized tool invocation process.
  • 🔄 Real-time display of tool execution progress.
  • 📚 Sidebar shows all available tools.
• Environment Configuration: Need to fill in DEEPSEEK_API_KEY and the MCP Server address in mylib/llm/llm_config.toml.

⚙️ (4) Configuration Layer: Config --done--

Used for configuration loading, already complete.

• Testing: uv run python ./tests/config.test.py
• Documentation: UserGuide.md (Click to jump)

🧠 (5) Agent Layer: Agent --pedding--

Defines the base class and core behavior patterns of agents.

• Design Philosophy: Self-awareness is the starting point of everything. Each Agent must have three core elements:
  • Identity: Clear role positioning and ability boundaries.
  • Objectives: Current task goals and work scope.
  • Memory: Short-term operation records, long-term experience accumulation, and meta-cognitive reflection.
• Documentation: Agent Design Documentation (Click to jump)

🕹️ (6) Core Layer: Core --pedding--

The core hub of the system, responsible for the scheduling and collaboration management of multi-expert agents.

• Core Responsibilities (Admin Agent):
  • Task Orchestration: Receives user input and decomposes it into an executable sequence of subtasks.
  • Expert Scheduling: Automatically generates (Spawn) or wakes up specific role expert agents according to task requirements.
  • Lifecycle Management: Controls the creation, operation, and destruction of agents.
  • Message Routing: Manages the communication protocol between agents and between agents and the Admin.
  • Result Convergence: Summarizes the outputs of each expert to generate the final response. This is the "brain" of the entire system, implementing the multi-expert collaboration architecture mentioned in the thesis.

🛠️ (7) Tool Library: Kit (formerly Utils)

Contains a series of self-developed basic tool libraries to support upper-level modules.

• 🎨 Terminal Beautification:
  • Printer: A basic color printing tool. Simple, lightweight, and ready to use, suitable for quickly outputting colored debugging information or logs without complex configuration.
  • Loutput: An advanced terminal output library that supports ANSI/256-color/true color (RGB 24bit) and provides color degradation compatibility. It has a rich color mapping table and style processor, which can automatically detect the terminal color support ability and adapt it, making terminal interface development as elegant as front-end development.
    • Loutput Usage Documentation | Terminal Color Guide | RGBColor Guide
• 🧩 Algorithms and Data Structures:
  • Lstack: An encapsulated standard stack structure. Provides rigorous push and pop interfaces, supporting the iterator pattern. It is the basic container for implementing pushdown automata and recursive algorithms.
    • Lstack Design Documentation (Click to jump)
  • Lfsm: A general finite state machine (Finite State Machine) base class. Defines states and transition rules through inheritance, with clear logic and easy maintenance. Widely used in protocol parsing and process control scenarios.
    • Lfsm Design Documentation (Click to jump)
  • Lpda: A pushdown automaton (Pushdown Automaton) that supports nested structure parsing. Combines the characteristics of a finite state machine and a stack, specifically used for processing recursive syntax structures such as bracket matching and code block parsing.
    • Lpda Design Documentation (Click to jump)
• 📝 Text Processing:
  • Ltokenizer: A general tokenizer base class based on a state machine. Supports streaming processing and position tracking (line number/column number), capable of efficiently converting raw text into a structured token sequence, providing standard input for parsers.
    • Ltokenizer Design Documentation (Click to jump)
  • Lparser: A general parser base class based on LPDA, used for building complex syntax analyzers. Provides flexible parsing hooks and context management mechanisms. Developers only need to focus on defining syntax rules to quickly build powerful custom language parsers.
    • Lparser Design Documentation (Click to jump)
  • Lfind: A vector embedding (Embedding) tool encapsulation for knowledge base retrieval. Integrates mainstream Embedding model interfaces, providing out-of-the-box text vectorization and similarity matching functions. It is the core component of the RAG (Retrieval Augmented Generation) system.

🎓 Academic Usage Declaration

This project is the graduation design work of the class of 2025.

⚠️ Important Note

• Protection period: November 10, 2025 - January 19, 2026.
• During this period, students from the same school are prohibited from using this project for graduation design.
• Any form of academic assignment submission is prohibited.
• Please refer to the LICENSE file for detailed terms.

🧪 Testing and Examples

The project contains complete test cases, located in the tests/ directory.

Running Methods

Use uv to run test files:

uv run python tests/{TEST_FILE_NAME}

List of Test Files

🐷 Piggy Talk

Insights left during the development process. Actually, I haven't recorded them... A lot of interesting ideas have been lost.

📅 November 24, 2025

• Oh no, my development habits seem to be a bit too extreme. If this goes on, I won't be able to finish the development!

📅 December 2, 2025

• The scale of the entire project has reached 48 directories and 144 files... Sometimes I even can't remember what each file is for.
• I really like lian_orm, but there isn't enough time at present... I can only leave it for future refactoring.