Mini LLM Flow: Building LLM Mini-Intelligents with "Directed Graph Structure" in 100 Lines of Code

General Introduction

miniLLMFlow is a minimalist Large Language Model (LLM) development framework that contains only 100 lines of core code, demonstrating the design philosophy of "The Way is Simple". The framework is specifically designed to enable AI assistants (e.g. ChatGPT, Claude, etc.) to program autonomously, supporting advanced features such as multi-intelligence, task decomposition, and RAG search enhancement. The project uses the MIT open source protocol and is continuously updated and maintained on the GitHub platform. Its best features areModeling LLM workflows as nested directed graph structures, processing simple tasks through nodes, connecting agents through actions (marking edges), realizing task decomposition through process orchestration nodes, and supporting process nesting and batch processing, which makes complex AI application development simple and intuitive.

Function List

• Support for multi-intelligence collaborative development systems
• Provide task decomposition and process organization functions
• Implementation of RAG (Retrieval Augmented Generation) application development
• Supports node batch function for data-intensive tasks
• Provide nested directed graph structure for workflow management
• Integration of mainstream LLM assistants (e.g. ChatGPT, Claude)
• Support for customized tools and API wrappers
• Full documentation and tutorial support available

Using Help

1. Installation configuration

Way 1: Installation via pip

pip install minillmflow

Approach 2: Direct use of source code

Quickly integrate into your project by copying the source code file (only 100 lines) directly from the project.

2. Description of the infrastructure

miniLLMFlow uses a nested directed graph structure and contains the following core concepts:

• Nodes: Basic unit for processing individual LLM tasks
• Actions: labeled edges of connected nodes for interactions between intelligences
• Flows: Directed graphs formed by orchestration nodes for task decomposition
• Nesting: Processes can be reused as nodes to support complex application construction
• Batch: Support for parallel processing of data-intensive tasks

3. Guide to the development process

1. design phase
   • Define high-level processes and node structures
   • Designing Shared Memory Structures
   • Define data fields and update methods
2. Realization phase
   • Start with a simple implementation
   • Step-by-step addition of complex functionality
   • Using the LLM Assistant to aid in development
3. Developed with LLM Assistant
   • Project Development with Claude::
     1. Create a new project and upload documents
     2. Setting up project customization commands
     3. Let Claude assist in the design and realization
   • Developing with ChatGPT::
     1. Use a specialized GPT assistant
     2. Option to use newer models for code development

4. Getting Started Example

The project provides a complete introductory tutorial showing how to implement the Paul Graham article abstraction and QA proxy system, which can be quickly experienced by getting started with Google Colab.

5. Best practices

• Start with simple functionality and expand gradually
• Leverage LLM Assistant for Development
• Refer to the sample code in the documentation
• Use the built-in debugging and testing tools
• Follow project updates and community discussions