PocketFlow: A Minimalist Framework for AI Application Development in 100 Lines of Code

General Introduction

PocketFlow is a lightweight AI application development framework with only 100 lines of code, developed by The-Pocket team and open-sourced on GitHub. It pursues a minimalist design, the core code is controlled in 100 lines, there are no external dependencies, and there are no vendor bindings. Developers can use it to quickly build AI applications, support for multi-intelligence, workflow, retrieval augmentation generation (RAG) and other functions. Its highlight is "Agentic Coding", that is, let AI intelligences (such as the Cursor PocketFlow starts from the most basic graph structure and uses the least amount of code to realize powerful functions, which is very suitable for individuals or teams who need to develop AI applications quickly.

Because of the relatively small amount of code, the project also provides a .cursorrules configuration file that automates the writing of smart body applications in Cursor.

Function List

• Only 100 lines of core code: Streamlined to 100 lines, easy to read and change.
• Graph-based structure: Define AI tasks in terms of nodes and connections.
• Multi-intelligence support: Multiple AI intelligences can collaborate on tasks.
• Built-in workflow: Task breakdown and order of execution at a glance.
• Retrieval Augmentation Generation (RAG): Combine external data to improve the quality of output.
• AI Self-Programming (Agentic Coding): AI can write its own code and save time.
• zero dependency design: No additional libraries required, just run it.
• Compatible with any LLM: Any large language model can be accessed.

Using Help

Installation process

The installation of PocketFlow is very simple and does not require complex environment configuration. The following are two ways to install PocketFlow:

Method 1: Installation via pip

1. Open a command line tool (CMD for Windows, Terminal for Mac).
2. Enter the command:pip install pocketflow, and then press Enter.
3. The installation process takes only a few seconds and is ready to use when finished.
4. Verify the installation: at the command line type python -c "import pocketflow; print(pocketflow.__version__)"If the version number is displayed, it indicates success.

Method 2: Directly copy the source code

1. Open your browser and go to https://github.com/The-Pocket/PocketFlow.
2. Click the "Code" button in the upper right corner and select "Download ZIP" to download the source code.
3. Unzip the file and find the pocketflow/__init__.py(That's 100 lines of core code).
4. Copy this file to your project folder.
5. Import in Python code:import pocketflowYou can start using it.

How to use the main features

At its core, PocketFlow is a Graph-based framework that organizes AI tasks through Nodes and Connections (Flow). Here's how it works:

1. Creating basic workflows

• move::
  1. Create a new Python file such as test_flow.pyThe
  2. Enter the following code:

     import pocketflow
     flow = pocketflow.Flow()
     flow.add_node("hello", lambda x: print("Hello, PocketFlow!"))
     flow.run()
     

  3. Run it from the command line:python test_flow.pyThe
  4. The screen will display "Hello PocketFlow!".
• clarification: This is a simple workflow containing a node that prints messages.

2. Use of multi-intelligence functions

• move::
  1. Modify the code to include multiple intelligences:

     import pocketflow
     flow = pocketflow.Flow()
     flow.add_node("agent1", lambda x: "Intelligence 1 says: Hello")
     flow.add_node("agent2", lambda x: f "Intelligence 2 replies: {x}, you too")
     flow.connect("agent1", "agent2")
     result = flow.run()
     print(result)
     

  2. When run, it outputs the dialog between the intelligences.
• clarification::connect The method connects two nodes and the data flows from "agent1" to "agent2".

3. Adding RAG functionality

• move::
  1. Create a text file info.txt, write something like, "PocketFlow is a lightweight AI framework."
  2. Modify the code:

     import pocketflow
     flow = pocketflow.Flow()
     def get_data(x).
     with open("info.txt", "r", encoding="utf-8") as f:: return f.read().
     return f.read()
     flow.add_node("retrieve", get_data)
     flow.add_node("generate", lambda x: f "Generate result: {x}")
     flow.connect("retrieve", "generate")
     result = flow.run()
     print(result)
     

  3. After running, the contents of the file and the generated results are output.
• clarification: The RAG reads the external data through the "retrieve" node and passes it to the "generate" node for processing.

4. Use of Agentic Coding (AI self-programming)

• move::
  1. Install a tool that supports code generation, such as Cursor AI.
  2. Enter the requirement in Cursor AI: "Write a program that calculates the sum of 1 to 10 using PocketFlow".
  3. AI may generate:

     import pocketflow
     flow = pocketflow.Flow()
     flow.add_node("numbers", lambda x: list(range(1, 11)))
     flow.add_node("sum", lambda x: sum(x))
     flow.connect("numbers", "sum")
     result = flow.run()
     print(f "The sum is: {result}")
     

  4. After running, the output is "The sum is: 55".
• clarification: AI generates PocketFlow code directly, developers just copy and run.

5. Access to external LLM

• move::
  1. Assuming you have the OpenAI API key, modify the code:

     import pocketflow
     from openai import OpenAI
     client = OpenAI(api_key="your API key")
     flow = pocketflow.Flow()
     flow.add_node("ask", lambda x: client.chat.completions.create(
     model="gpt-3.5-turbo",
     messages=[{"role": "user", "content": "hello"}]
     ).choices[0].message.content)
     result = flow.run()
     print(result)
     

  2. When run, it will output the model's responses.
• clarification: PocketFlow is not bound to any LLM and you can access it freely.

Summary of the operation process

1. Install PocketFlow (using pip or copying the source code).
2. Create a new Python file, import pocketflowThe
3. expense or outlay Flow() Create workflows, add nodes and connections.
4. invocations run() Perform tasks and check results.
5. Adjust node functionality to include intelligences or RAGs as needed.

caveat

• Python version 3.6 or higher is recommended.
• If using an external LLM, you need to configure the API and network.
• For more examples and usage see the official documentation at https://the-pocket.github.io/PocketFlow/.

application scenario

1. Rapid validation of AI ideas
   You want to make an autoresponder, prototype it in minutes with PocketFlow.
2. Learn AI Development
   Students or novices can practice with it because the code is simple and logical.
3. Small task automation
   For example, to summarize a document or generate an email, PocketFlow makes quick work of it.
4. Teamwork Development
   Multiple people can use it to divide up the design of nodes and quickly put together applications.

QA

1. How is PocketFlow different from other frameworks?
   It's only 100 lines of code, has no dependencies, and is lighter than other frameworks (such as LangChain's 400,000 lines).
2. Do I need additional tools for AI self-programming?
   Yes, it is recommended to use Cursor AI or a similar tool with it.
3. Is it commercially available?
   Yes, it is open source, see the GitHub page for the exact license.