├── utils
├── __init__.py
└── call_llm.py
├── requirements.txt
├── assets
└── banner.png
├── main.py
├── flow.py
├── nodes.py
├── README.md
├── .gitignore
├── docs
└── design.md
├── .clinerules
├── .cursorrules
└── .goosehints
/utils/__init__.py:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | pocketflow>=0.0.1
--------------------------------------------------------------------------------
/assets/banner.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/The-Pocket/PocketFlow-Template-Python/main/assets/banner.png
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | from flow import create_qa_flow
2 |
3 | # Example main function
4 | # Please replace this with your own main function
5 | def main():
6 | shared = {
7 | "question": "In one sentence, what's the end of universe?",
8 | "answer": None
9 | }
10 |
11 | qa_flow = create_qa_flow()
12 | qa_flow.run(shared)
13 | print("Question:", shared["question"])
14 | print("Answer:", shared["answer"])
15 |
16 | if __name__ == "__main__":
17 | main()
18 |
--------------------------------------------------------------------------------
/flow.py:
--------------------------------------------------------------------------------
1 | from pocketflow import Flow
2 | from nodes import GetQuestionNode, AnswerNode
3 |
4 | def create_qa_flow():
5 | """Create and return a question-answering flow."""
6 | # Create nodes
7 | get_question_node = GetQuestionNode()
8 | answer_node = AnswerNode()
9 |
10 | # Connect nodes in sequence
11 | get_question_node >> answer_node
12 |
13 | # Create flow starting with input node
14 | return Flow(start=get_question_node)
15 |
16 | qa_flow = create_qa_flow()
--------------------------------------------------------------------------------
/utils/call_llm.py:
--------------------------------------------------------------------------------
1 | from openai import OpenAI
2 | import os
3 |
4 | # Learn more about calling the LLM: https://the-pocket.github.io/PocketFlow/utility_function/llm.html
5 | def call_llm(prompt):
6 | client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", "your-api-key"))
7 | r = client.chat.completions.create(
8 | model="gpt-4o",
9 | messages=[{"role": "user", "content": prompt}]
10 | )
11 | return r.choices[0].message.content
12 |
13 | if __name__ == "__main__":
14 | prompt = "What is the meaning of life?"
15 | print(call_llm(prompt))
16 |
--------------------------------------------------------------------------------
/nodes.py:
--------------------------------------------------------------------------------
1 | from pocketflow import Node
2 | from utils.call_llm import call_llm
3 |
4 | class GetQuestionNode(Node):
5 | def exec(self, _):
6 | # Get question directly from user input
7 | user_question = input("Enter your question: ")
8 | return user_question
9 |
10 | def post(self, shared, prep_res, exec_res):
11 | # Store the user's question
12 | shared["question"] = exec_res
13 | return "default" # Go to the next node
14 |
15 | class AnswerNode(Node):
16 | def prep(self, shared):
17 | # Read question from shared
18 | return shared["question"]
19 |
20 | def exec(self, question):
21 | # Call LLM to get the answer
22 | return call_llm(question)
23 |
24 | def post(self, shared, prep_res, exec_res):
25 | # Store the answer in shared
26 | shared["answer"] = exec_res
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Pocket Flow Project Template: Agentic Coding
2 |
3 |
4 |
5 | 
8 |
9 |
10 |
11 | This is a project template for Agentic Coding with [Pocket Flow](https://github.com/The-Pocket/PocketFlow), a 100-line LLM framework, and your editor of choice.
12 |
13 | - We have included rules files for various AI coding assistants to help you build LLM projects:
14 | - [.cursorrules](.cursorrules) for Cursor AI
15 | - [.clinerules](.clinerules) for Cline
16 | - [.windsurfrules](.windsurfrules) for Windsurf
17 | - [.goosehints](.goosehints) for Goose
18 | - Configuration in [.github](.github) for GitHub Copilot
19 | - [CLAUDE.md](CLAUDE.md) for Claude Code
20 | - [GEMINI.md](GEMINI.md) for Gemini
21 |
22 | - Want to learn how to build LLM projects with Agentic Coding?
23 |
24 | - Check out the [Agentic Coding Guidance](https://the-pocket.github.io/PocketFlow/guide.html)
25 |
26 | - Check out the [YouTube Tutorial](https://www.youtube.com/@ZacharyLLM?sub_confirmation=1)
27 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Dependencies
2 | node_modules/
3 | vendor/
4 | .pnp/
5 | .pnp.js
6 |
7 | # Build outputs
8 | dist/
9 | build/
10 | out/
11 | *.pyc
12 | __pycache__/
13 |
14 | # Environment files
15 | .env
16 | .env.local
17 | .env.*.local
18 | .env.development
19 | .env.test
20 | .env.production
21 |
22 | # IDE - VSCode
23 | .vscode/*
24 | !.vscode/settings.json
25 | !.vscode/tasks.json
26 | !.vscode/launch.json
27 | !.vscode/extensions.json
28 |
29 | # IDE - JetBrains
30 | .idea/
31 | *.iml
32 | *.iws
33 | *.ipr
34 |
35 | # IDE - Eclipse
36 | .project
37 | .classpath
38 | .settings/
39 |
40 | # Logs
41 | logs/
42 | *.log
43 | npm-debug.log*
44 | yarn-debug.log*
45 | yarn-error.log*
46 |
47 | # Operating System
48 | .DS_Store
49 | Thumbs.db
50 | *.swp
51 | *.swo
52 |
53 | # Testing
54 | coverage/
55 | .nyc_output/
56 |
57 | # Temporary files
58 | *.tmp
59 | *.temp
60 | .cache/
61 |
62 | # Compiled files
63 | *.com
64 | *.class
65 | *.dll
66 | *.exe
67 | *.o
68 | *.so
69 |
70 | # Package files
71 | *.7z
72 | *.dmg
73 | *.gz
74 | *.iso
75 | *.jar
76 | *.rar
77 | *.tar
78 | *.zip
79 |
80 | # Database
81 | *.sqlite
82 | *.sqlite3
83 | *.db
84 |
85 | # Optional npm cache directory
86 | .npm
87 |
88 | # Optional eslint cache
89 | .eslintcache
90 |
91 | # Optional REPL history
92 | .node_repl_history
--------------------------------------------------------------------------------
/docs/design.md:
--------------------------------------------------------------------------------
1 | # Design Doc: Your Project Name
2 |
3 | > Please DON'T remove notes for AI
4 |
5 | ## Requirements
6 |
7 | > Notes for AI: Keep it simple and clear.
8 | > If the requirements are abstract, write concrete user stories
9 |
10 |
11 | ## Flow Design
12 |
13 | > Notes for AI:
14 | > 1. Consider the design patterns of agent, map-reduce, rag, and workflow. Apply them if they fit.
15 | > 2. Present a concise, high-level description of the workflow.
16 |
17 | ### Applicable Design Pattern:
18 |
19 | 1. Map the file summary into chunks, then reduce these chunks into a final summary.
20 | 2. Agentic file finder
21 | - *Context*: The entire summary of the file
22 | - *Action*: Find the file
23 |
24 | ### Flow high-level Design:
25 |
26 | 1. **First Node**: This node is for ...
27 | 2. **Second Node**: This node is for ...
28 | 3. **Third Node**: This node is for ...
29 |
30 | ```mermaid
31 | flowchart TD
32 | firstNode[First Node] --> secondNode[Second Node]
33 | secondNode --> thirdNode[Third Node]
34 | ```
35 | ## Utility Functions
36 |
37 | > Notes for AI:
38 | > 1. Understand the utility function definition thoroughly by reviewing the doc.
39 | > 2. Include only the necessary utility functions, based on nodes in the flow.
40 |
41 | 1. **Call LLM** (`utils/call_llm.py`)
42 | - *Input*: prompt (str)
43 | - *Output*: response (str)
44 | - Generally used by most nodes for LLM tasks
45 |
46 | 2. **Embedding** (`utils/get_embedding.py`)
47 | - *Input*: str
48 | - *Output*: a vector of 3072 floats
49 | - Used by the second node to embed text
50 |
51 | ## Node Design
52 |
53 | ### Shared Store
54 |
55 | > Notes for AI: Try to minimize data redundancy
56 |
57 | The shared store structure is organized as follows:
58 |
59 | ```python
60 | shared = {
61 | "key": "value"
62 | }
63 | ```
64 |
65 | ### Node Steps
66 |
67 | > Notes for AI: Carefully decide whether to use Batch/Async Node/Flow.
68 |
69 | 1. First Node
70 | - *Purpose*: Provide a short explanation of the node’s function
71 | - *Type*: Decide between Regular, Batch, or Async
72 | - *Steps*:
73 | - *prep*: Read "key" from the shared store
74 | - *exec*: Call the utility function
75 | - *post*: Write "key" to the shared store
76 |
77 | 2. Second Node
78 | ...
79 |
80 |
--------------------------------------------------------------------------------
/.clinerules:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | title: "Agentic Coding"
4 | ---
5 |
6 | # Agentic Coding: Humans Design, Agents code!
7 |
8 | > If you are an AI agent involved in building LLM Systems, read this guide **VERY, VERY** carefully! This is the most important chapter in the entire document. Throughout development, you should always (1) start with a small and simple solution, (2) design at a high level (`docs/design.md`) before implementation, and (3) frequently ask humans for feedback and clarification.
9 | {: .warning }
10 |
11 | ## Agentic Coding Steps
12 |
13 | Agentic Coding should be a collaboration between Human System Design and Agent Implementation:
14 |
15 | | Steps | Human | AI | Comment |
16 | |:-----------------------|:----------:|:---------:|:------------------------------------------------------------------------|
17 | | 1. Requirements | ★★★ High | ★☆☆ Low | Humans understand the requirements and context. |
18 | | 2. Flow | ★★☆ Medium | ★★☆ Medium | Humans specify the high-level design, and the AI fills in the details. |
19 | | 3. Utilities | ★★☆ Medium | ★★☆ Medium | Humans provide available external APIs and integrations, and the AI helps with implementation. |
20 | | 4. Data | ★☆☆ Low | ★★★ High | AI designs the data schema, and humans verify. |
21 | | 5. Node | ★☆☆ Low | ★★★ High | The AI helps design the node based on the flow. |
22 | | 6. Implementation | ★☆☆ Low | ★★★ High | The AI implements the flow based on the design. |
23 | | 7. Optimization | ★★☆ Medium | ★★☆ Medium | Humans evaluate the results, and the AI helps optimize. |
24 | | 8. Reliability | ★☆☆ Low | ★★★ High | The AI writes test cases and addresses corner cases. |
25 |
26 | 1. **Requirements**: Clarify the requirements for your project, and evaluate whether an AI system is a good fit.
27 | - Understand AI systems' strengths and limitations:
28 | - **Good for**: Routine tasks requiring common sense (filling forms, replying to emails)
29 | - **Good for**: Creative tasks with well-defined inputs (building slides, writing SQL)
30 | - **Not good for**: Ambiguous problems requiring complex decision-making (business strategy, startup planning)
31 | - **Keep It User-Centric:** Explain the "problem" from the user's perspective rather than just listing features.
32 | - **Balance complexity vs. impact**: Aim to deliver the highest value features with minimal complexity early.
33 |
34 | 2. **Flow Design**: Outline at a high level, describe how your AI system orchestrates nodes.
35 | - Identify applicable design patterns (e.g., [Map Reduce](./design_pattern/mapreduce.md), [Agent](./design_pattern/agent.md), [RAG](./design_pattern/rag.md)).
36 | - For each node in the flow, start with a high-level one-line description of what it does.
37 | - If using **Map Reduce**, specify how to map (what to split) and how to reduce (how to combine).
38 | - If using **Agent**, specify what are the inputs (context) and what are the possible actions.
39 | - If using **RAG**, specify what to embed, noting that there's usually both offline (indexing) and online (retrieval) workflows.
40 | - Outline the flow and draw it in a mermaid diagram. For example:
41 | ```mermaid
42 | flowchart LR
43 | start[Start] --> batch[Batch]
44 | batch --> check[Check]
45 | check -->|OK| process
46 | check -->|Error| fix[Fix]
47 | fix --> check
48 |
49 | subgraph process[Process]
50 | step1[Step 1] --> step2[Step 2]
51 | end
52 |
53 | process --> endNode[End]
54 | ```
55 | - > **If Humans can't specify the flow, AI Agents can't automate it!** Before building an LLM system, thoroughly understand the problem and potential solution by manually solving example inputs to develop intuition.
56 | {: .best-practice }
57 |
58 | 3. **Utilities**: Based on the Flow Design, identify and implement necessary utility functions.
59 | - Think of your AI system as the brain. It needs a body—these *external utility functions*—to interact with the real world:
60 |
61 |
62 | - Reading inputs (e.g., retrieving Slack messages, reading emails)
63 | - Writing outputs (e.g., generating reports, sending emails)
64 | - Using external tools (e.g., calling LLMs, searching the web)
65 | - **NOTE**: *LLM-based tasks* (e.g., summarizing text, analyzing sentiment) are **NOT** utility functions; rather, they are *core functions* internal in the AI system.
66 | - For each utility function, implement it and write a simple test.
67 | - Document their input/output, as well as why they are necessary. For example:
68 | - `name`: `get_embedding` (`utils/get_embedding.py`)
69 | - `input`: `str`
70 | - `output`: a vector of 3072 floats
71 | - `necessity`: Used by the second node to embed text
72 | - Example utility implementation:
73 | ```python
74 | # utils/call_llm.py
75 | from openai import OpenAI
76 |
77 | def call_llm(prompt):
78 | client = OpenAI(api_key="YOUR_API_KEY_HERE")
79 | r = client.chat.completions.create(
80 | model="gpt-4o",
81 | messages=[{"role": "user", "content": prompt}]
82 | )
83 | return r.choices[0].message.content
84 |
85 | if __name__ == "__main__":
86 | prompt = "What is the meaning of life?"
87 | print(call_llm(prompt))
88 | ```
89 | - > **Sometimes, design Utilities before Flow:** For example, for an LLM project to automate a legacy system, the bottleneck will likely be the available interface to that system. Start by designing the hardest utilities for interfacing, and then build the flow around them.
90 | {: .best-practice }
91 | - > **Avoid Exception Handling in Utilities**: If a utility function is called from a Node's `exec()` method, avoid using `try...except` blocks within the utility. Let the Node's built-in retry mechanism handle failures.
92 | {: .warning }
93 |
94 | 4. **Data Design**: Design the shared store that nodes will use to communicate.
95 | - One core design principle for PocketFlow is to use a well-designed [shared store](./core_abstraction/communication.md)—a data contract that all nodes agree upon to retrieve and store data.
96 | - For simple systems, use an in-memory dictionary.
97 | - For more complex systems or when persistence is required, use a database.
98 | - **Don't Repeat Yourself**: Use in-memory references or foreign keys.
99 | - Example shared store design:
100 | ```python
101 | shared = {
102 | "user": {
103 | "id": "user123",
104 | "context": { # Another nested dict
105 | "weather": {"temp": 72, "condition": "sunny"},
106 | "location": "San Francisco"
107 | }
108 | },
109 | "results": {} # Empty dict to store outputs
110 | }
111 | ```
112 |
113 | 5. **Node Design**: Plan how each node will read and write data, and use utility functions.
114 | - For each [Node](./core_abstraction/node.md), describe its type, how it reads and writes data, and which utility function it uses. Keep it specific but high-level without codes. For example:
115 | - `type`: Regular (or Batch, or Async)
116 | - `prep`: Read "text" from the shared store
117 | - `exec`: Call the embedding utility function. **Avoid exception handling here**; let the Node's retry mechanism manage failures.
118 | - `post`: Write "embedding" to the shared store
119 |
120 | 6. **Implementation**: Implement the initial nodes and flows based on the design.
121 | - 🎉 If you've reached this step, humans have finished the design. Now *Agentic Coding* begins!
122 | - **"Keep it simple, stupid!"** Avoid complex features and full-scale type checking.
123 | - **FAIL FAST**! Leverage the built-in [Node](./core_abstraction/node.md) retry and fallback mechanisms to handle failures gracefully. This helps you quickly identify weak points in the system.
124 | - Add logging throughout the code to facilitate debugging.
125 |
126 | 7. **Optimization**:
127 | - **Use Intuition**: For a quick initial evaluation, human intuition is often a good start.
128 | - **Redesign Flow (Back to Step 3)**: Consider breaking down tasks further, introducing agentic decisions, or better managing input contexts.
129 | - If your flow design is already solid, move on to micro-optimizations:
130 | - **Prompt Engineering**: Use clear, specific instructions with examples to reduce ambiguity.
131 | - **In-Context Learning**: Provide robust examples for tasks that are difficult to specify with instructions alone.
132 |
133 | - > **You'll likely iterate a lot!** Expect to repeat Steps 3–6 hundreds of times.
134 | >
135 | >
136 | {: .best-practice }
137 |
138 | 8. **Reliability**
139 | - **Node Retries**: Add checks in the node `exec` to ensure outputs meet requirements, and consider increasing `max_retries` and `wait` times.
140 | - **Logging and Visualization**: Maintain logs of all attempts and visualize node results for easier debugging.
141 | - **Self-Evaluation**: Add a separate node (powered by an LLM) to review outputs when results are uncertain.
142 |
143 | ## Example LLM Project File Structure
144 |
145 | ```
146 | my_project/
147 | ├── main.py
148 | ├── nodes.py
149 | ├── flow.py
150 | ├── utils/
151 | │ ├── __init__.py
152 | │ ├── call_llm.py
153 | │ └── search_web.py
154 | ├── requirements.txt
155 | └── docs/
156 | └── design.md
157 | ```
158 |
159 | - **`requirements.txt`**: Lists the Python dependencies for the project.
160 | ```
161 | PyYAML
162 | pocketflow
163 | ```
164 |
165 | - **`docs/design.md`**: Contains project documentation for each step above. This should be *high-level* and *no-code*.
166 | ~~~
167 | # Design Doc: Your Project Name
168 |
169 | > Please DON'T remove notes for AI
170 |
171 | ## Requirements
172 |
173 | > Notes for AI: Keep it simple and clear.
174 | > If the requirements are abstract, write concrete user stories
175 |
176 |
177 | ## Flow Design
178 |
179 | > Notes for AI:
180 | > 1. Consider the design patterns of agent, map-reduce, rag, and workflow. Apply them if they fit.
181 | > 2. Present a concise, high-level description of the workflow.
182 |
183 | ### Applicable Design Pattern:
184 |
185 | 1. Map the file summary into chunks, then reduce these chunks into a final summary.
186 | 2. Agentic file finder
187 | - *Context*: The entire summary of the file
188 | - *Action*: Find the file
189 |
190 | ### Flow high-level Design:
191 |
192 | 1. **First Node**: This node is for ...
193 | 2. **Second Node**: This node is for ...
194 | 3. **Third Node**: This node is for ...
195 |
196 | ```mermaid
197 | flowchart TD
198 | firstNode[First Node] --> secondNode[Second Node]
199 | secondNode --> thirdNode[Third Node]
200 | ```
201 | ## Utility Functions
202 |
203 | > Notes for AI:
204 | > 1. Understand the utility function definition thoroughly by reviewing the doc.
205 | > 2. Include only the necessary utility functions, based on nodes in the flow.
206 |
207 | 1. **Call LLM** (`utils/call_llm.py`)
208 | - *Input*: prompt (str)
209 | - *Output*: response (str)
210 | - Generally used by most nodes for LLM tasks
211 |
212 | 2. **Embedding** (`utils/get_embedding.py`)
213 | - *Input*: str
214 | - *Output*: a vector of 3072 floats
215 | - Used by the second node to embed text
216 |
217 | ## Node Design
218 |
219 | ### Shared Store
220 |
221 | > Notes for AI: Try to minimize data redundancy
222 |
223 | The shared store structure is organized as follows:
224 |
225 | ```python
226 | shared = {
227 | "key": "value"
228 | }
229 | ```
230 |
231 | ### Node Steps
232 |
233 | > Notes for AI: Carefully decide whether to use Batch/Async Node/Flow.
234 |
235 | 1. First Node
236 | - *Purpose*: Provide a short explanation of the node’s function
237 | - *Type*: Decide between Regular, Batch, or Async
238 | - *Steps*:
239 | - *prep*: Read "key" from the shared store
240 | - *exec*: Call the utility function
241 | - *post*: Write "key" to the shared store
242 |
243 | 2. Second Node
244 | ...
245 | ~~~
246 |
247 |
248 | - **`utils/`**: Contains all utility functions.
249 | - It's recommended to dedicate one Python file to each API call, for example `call_llm.py` or `search_web.py`.
250 | - Each file should also include a `main()` function to try that API call
251 | ```python
252 | from google import genai
253 | import os
254 |
255 | def call_llm(prompt: str) -> str:
256 | client = genai.Client(
257 | api_key=os.getenv("GEMINI_API_KEY", ""),
258 | )
259 | model = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
260 | response = client.models.generate_content(model=model, contents=[prompt])
261 | return response.text
262 |
263 | if __name__ == "__main__":
264 | test_prompt = "Hello, how are you?"
265 |
266 | # First call - should hit the API
267 | print("Making call...")
268 | response1 = call_llm(test_prompt, use_cache=False)
269 | print(f"Response: {response1}")
270 | ```
271 |
272 | - **`nodes.py`**: Contains all the node definitions.
273 | ```python
274 | # nodes.py
275 | from pocketflow import Node
276 | from utils.call_llm import call_llm
277 |
278 | class GetQuestionNode(Node):
279 | def exec(self, _):
280 | # Get question directly from user input
281 | user_question = input("Enter your question: ")
282 | return user_question
283 |
284 | def post(self, shared, prep_res, exec_res):
285 | # Store the user's question
286 | shared["question"] = exec_res
287 | return "default" # Go to the next node
288 |
289 | class AnswerNode(Node):
290 | def prep(self, shared):
291 | # Read question from shared
292 | return shared["question"]
293 |
294 | def exec(self, question):
295 | # Call LLM to get the answer
296 | return call_llm(question)
297 |
298 | def post(self, shared, prep_res, exec_res):
299 | # Store the answer in shared
300 | shared["answer"] = exec_res
301 | ```
302 | - **`flow.py`**: Implements functions that create flows by importing node definitions and connecting them.
303 | ```python
304 | # flow.py
305 | from pocketflow import Flow
306 | from nodes import GetQuestionNode, AnswerNode
307 |
308 | def create_qa_flow():
309 | """Create and return a question-answering flow."""
310 | # Create nodes
311 | get_question_node = GetQuestionNode()
312 | answer_node = AnswerNode()
313 |
314 | # Connect nodes in sequence
315 | get_question_node >> answer_node
316 |
317 | # Create flow starting with input node
318 | return Flow(start=get_question_node)
319 | ```
320 | - **`main.py`**: Serves as the project's entry point.
321 | ```python
322 | # main.py
323 | from flow import create_qa_flow
324 |
325 | # Example main function
326 | # Please replace this with your own main function
327 | def main():
328 | shared = {
329 | "question": None, # Will be populated by GetQuestionNode from user input
330 | "answer": None # Will be populated by AnswerNode
331 | }
332 |
333 | # Create the flow and run it
334 | qa_flow = create_qa_flow()
335 | qa_flow.run(shared)
336 | print(f"Question: {shared['question']}")
337 | print(f"Answer: {shared['answer']}")
338 |
339 | if __name__ == "__main__":
340 | main()
341 | ```
342 |
343 | ================================================
344 | File: docs/index.md
345 | ================================================
346 | ---
347 | layout: default
348 | title: "Home"
349 | nav_order: 1
350 | ---
351 |
352 | # Pocket Flow
353 |
354 | A [100-line](https://github.com/the-pocket/PocketFlow/blob/main/pocketflow/__init__.py) minimalist LLM framework for *Agents, Task Decomposition, RAG, etc*.
355 |
356 | - **Lightweight**: Just the core graph abstraction in 100 lines. ZERO dependencies, and vendor lock-in.
357 | - **Expressive**: Everything you love from larger frameworks—([Multi-](./design_pattern/multi_agent.html))[Agents](./design_pattern/agent.html), [Workflow](./design_pattern/workflow.html), [RAG](./design_pattern/rag.html), and more.
358 | - **Agentic-Coding**: Intuitive enough for AI agents to help humans build complex LLM applications.
359 |
360 |
361 |
362 |
376 |
377 |
391 |
392 |
911 |
912 |
1081 |
1082 |
1239 |
1240 |
1309 |
1310 |
1592 |
1593 |
361 |
362 |
376 |
377 |
391 |
392 |
911 |
912 |
1081 |
1082 |
1239 |
1240 |
1309 |
1310 |
1592 |
1593 |
361 |
362 |
376 |
377 |
391 |
392 |
911 |
912 |
1081 |
1082 |
1239 |
1240 |
1309 |
1310 |
1592 |
1593 |
