mirror of
https://github.com/infiniflow/ragflow.git
synced 2026-06-29 15:31:05 +08:00
3f805a64f1
## Summary
Aligns the **Go agent runtime/canvas/components/tools** behavior with
the **Python `agent/` implementation** so the same stored canvas DSL
produces the same execution result on either side. Every component,
tool, and runtime primitive in `internal/agent/` is now driven by the
same semantics as its Python counterpart — variable resolution, template
substitution, control flow, error reporting, retry/cancel, and stream
event shapes.
The **retrieval component is the one explicit exception** in this PR. It
is being reworked in a separate change and is excluded from this
alignment pass; the wrapper slot (`universe_a_wrappers.go →
newRetrievalComponent`) is preserved.
## Scope of alignment
### Components (all aligned with `agent/component/`)
`Begin` · `Message` · `LLM` (incl. ChatTemplateKwargs,
MessageHistoryWindowSize, VisualFiles, Cite, OutputStructure,
JSONOutput, TopP, MaxRetries, DelayAfterError, credentials) · `Agent`
(react + tool artifact capture + `Reset()` interface-assert) · `Switch`
(12/12 operators, Python-equivalent semantics) · `Categorize` · `Invoke`
· `Iteration` · `Loop` (macro-expansion through `workflowx.AddLoopNode`)
· `UserFillUp` (Python-equivalent interrupt/resume via eino
`compose.Interrupt`/`ResumeWithData`) · `FillUp` · `DataOperations` ·
`ListOperations` · `StringTransform` · `VariableAggregator` ·
`VariableAssigner` · `Browser` (full stagehand runtime parity) ·
`DocsGenerator` · `ExcelProcessor`.
### Tools (all aligned with `agent/tools/`)
`Retrieval` (wrapper slot only — logic out of scope) · `MCPToolAdapter`
(streamable-HTTP) · `CodeExec` (sandbox bridge with
`code_exec_contract.go` matching Python contract) · `AkShare` · `ArXiv`
· `Crawler` · `DeepL` · `DuckDuckGo` · `Email` · `ExeSQL` · `GitHub` ·
`Google` · `GoogleScholar` · `Jin10` · `PubMed` · `QWeather` · `SearXNG`
· `Tavily` · `Tushare` · `Wencai` · `Wikipedia` · `YahooFinance` —
uniform `eino tool.InvokableTool` interface, SSRF protection, shared
HTTP client.
### Canvas execution engine (`internal/agent/canvas/`)
Aligned with Python's `agent/canvas.py`:
- **Scheduler** (`scheduler.go`): state pre/post handlers, node lambdas,
per-component timeout resolver (4-level: per-class env → per-class table
→ uniform env → 600s fallback), `legacyNoOpNames`.
- **Loop subgraph** (`loop_subgraph.go`): Python-equivalent
`AddLoopNode` macro expansion + condition translation.
- **Multibranch** (`multibranch.go`): `Switch` / `Categorize` routing
via `compose.NewGraphMultiBranch` — same branch selection semantics as
Python.
- **Parallel subgraph** (`parallel_subgraph.go`): matches Python's
parallel fan-out contract.
- **Interrupt/Resume** (`interrupt_resume.go`): `UserFillUpNodeBody` /
`IsInterruptError` / `ExtractInterruptContexts` — replaces the
deprecated Python sentinel chain with eino's native interrupt API,
preserving the same external behavior.
- **Checkpoint** (`checkpoint_store.go`): `RedisCheckPointStore`
Get/Set/Delete, with business metadata (status / canvas_id /
parent_run_id) on a parallel Redis Hash.
- **RunTracker** (`run_tracker.go`): Start / MarkSucceeded / MarkFailed
/ MarkCancelled / AttachCheckpoint — same lifecycle as the Python run
record.
- **Cancel** (`cancel.go`): Redis pub/sub watch.
- **Stream** (`stream.go`): SSE channel with `messages` / `waiting` /
`errors` / `done` events, same shape as Python's `agent.canvas.RunEvent`
payload.
### DSL bridge (`internal/agent/dsl/`)
- `normalize.go`: v1↔v2 collapsed into a single wire format — Python and
Go consume the same stored JSON.
- `reset.go`: per-run state reset matches Python's `Canvas.reset()`
semantics.
- Testdata mirrors Python's `agent_msg.json` / `all.json` / etc.
### Runtime (`internal/agent/runtime/`)
- `CanvasState` / `NewCanvasState` / `GetVar` / `SetVar` / `ReadVars`:
same `{{cpn_id@param}}` resolution model.
- `ResolveTemplate` (regex fast path + gonja fallback) — Python
Jinja-style semantics.
- `selector.go`, `metrics.go`, `component.go`: shared runtime contracts.
## Out of scope (intentionally)
- **`Retrieval` component logic** — wrapped only; full parity lands in a
follow-up PR.
- **Frontend** — only minor dsl-bridge / canvas UX fixes ride along.
- **CLI / admin / model registry** — orthogonal to agent behavior.
## How alignment is verified
`internal/service/agent_run_e2e_test.go` exercises the **full production
chain** against real Python-shaped DSL fixtures:
```
loadCanvasForUser → versionDAO.GetLatest → decodeCanvasFromDSL →
canvas.Compile → cc.Workflow.Invoke → answer extraction
```
using in-memory SQLite + miniredis (no Docker). Covers:
- `TestRunAgent_RealCanvas_BeginMessage` — happy path, `{{sys.query}}`
resolution
- `TestRunAgent_RealCanvas_WaitForUserResume` — two-run resume cycle
(Python-equivalent)
- `TestRunAgent_RealCanvas_CompileFails` — unknown component name →
sanitized error (Python-equivalent)
- `TestRunAgent_RealCanvas_InvokeFails` — unresolvable template ref
(Python-equivalent)
- `TestRunAgent_RunTracker_AttachCheckpoint_CallSequence` —
Start→AttachCheckpoint→MarkSucceeded lifecycle
`internal/handler/agent_test.go` — SSE streaming parity (`Content-Type:
text/event-stream`, `data: {…}\n\n`, trailing `data: [DONE]\n\n`,
OpenAI-compatible non-stream `choices`).
`internal/agent/canvas/fixture_compile_test.go` + per-component tests
pin the Python-equivalent outputs.
```
go test -count=1 -v -run 'TestRunAgent_RealCanvas|TestRunAgent_RunTracker' ./internal/service/
```
## Design reference
`docs/develop/agent-go-port-design.md` (1329 lines, last cross-checked
2026-06-17) — module layout, per-component / per-tool inventory,
corner-case catalogue, and the actionable backlog (Section 14, including
the retrieval alignment follow-up).
---------
Co-authored-by: Claude <noreply@anthropic.com>
111 lines
2.7 KiB
Markdown
111 lines
2.7 KiB
Markdown
# RAGFlow Project Instructions for GitHub Copilot
|
|
|
|
This file provides context, build instructions, and coding standards for the RAGFlow project.
|
|
It is structured to follow GitHub Copilot's [customization guidelines](https://docs.github.com/en/copilot/concepts/prompting/response-customization).
|
|
|
|
## 1. Project Overview
|
|
RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine based on deep document understanding. It is a full-stack application with a Python backend and a React/TypeScript frontend.
|
|
|
|
- **Backend**: Python 3.10+ (Flask/Quart)
|
|
- **Frontend**: TypeScript, React, UmiJS
|
|
- **Architecture**: Microservices based on Docker.
|
|
- `api/`: Backend API server.
|
|
- `rag/`: Core RAG logic (indexing, retrieval).
|
|
- `deepdoc/`: Document parsing and OCR.
|
|
- `web/`: Frontend application.
|
|
|
|
## 2. Directory Structure
|
|
- `api/`: Backend API server (Flask/Quart).
|
|
- `apps/`: API Blueprints (Knowledge Base, Chat, etc.).
|
|
- `db/`: Database models and services.
|
|
- `rag/`: Core RAG logic.
|
|
- `llm/`: LLM, Embedding, and Rerank model abstractions.
|
|
- `deepdoc/`: Document parsing and OCR modules.
|
|
- `agent/`: Agentic reasoning components.
|
|
- `web/`: Frontend application (React + UmiJS).
|
|
- `docker/`: Docker deployment configurations.
|
|
- `sdk/`: Python SDK.
|
|
- `test/`: Backend tests.
|
|
|
|
## 3. Build Instructions
|
|
|
|
### Backend (Python)
|
|
The project uses **uv** for dependency management.
|
|
|
|
1. **Setup Environment**:
|
|
```bash
|
|
uv sync --python 3.13 --all-extras
|
|
uv run python3 ragflow_deps/download_deps.py
|
|
```
|
|
|
|
2. **Run Server**:
|
|
- **Pre-requisite**: Start dependent services (MySQL, ES/Infinity, Redis, MinIO).
|
|
```bash
|
|
docker compose -f docker/docker-compose-base.yml up -d
|
|
```
|
|
- **Launch**:
|
|
```bash
|
|
source .venv/bin/activate
|
|
export PYTHONPATH=$(pwd)
|
|
bash docker/launch_backend_service.sh
|
|
```
|
|
|
|
### Frontend (TypeScript/React)
|
|
Located in `web/`.
|
|
|
|
1. **Install Dependencies**:
|
|
```bash
|
|
cd web
|
|
npm install
|
|
```
|
|
|
|
2. **Run Dev Server**:
|
|
```bash
|
|
npm run dev
|
|
```
|
|
Runs on port 8000 by default.
|
|
|
|
### Docker Deployment
|
|
To run the full stack using Docker:
|
|
```bash
|
|
cd docker
|
|
docker compose -f docker-compose.yml up -d
|
|
```
|
|
|
|
## 4. Testing Instructions
|
|
|
|
### Backend Tests
|
|
- **Run All Tests**:
|
|
```bash
|
|
uv run pytest
|
|
```
|
|
- **Run Specific Test**:
|
|
```bash
|
|
uv run pytest test/test_api.py
|
|
```
|
|
|
|
### Frontend Tests
|
|
- **Run Tests**:
|
|
```bash
|
|
cd web
|
|
npm run test
|
|
```
|
|
|
|
## 5. Coding Standards & Guidelines
|
|
- **Python Formatting**: Use `ruff` for linting and formatting.
|
|
```bash
|
|
ruff check
|
|
ruff format
|
|
```
|
|
- **Frontend Linting**:
|
|
```bash
|
|
cd web
|
|
npm run lint
|
|
```
|
|
- **Pre-commit**: Ensure pre-commit hooks are installed.
|
|
```bash
|
|
pre-commit install
|
|
pre-commit run --all-files
|
|
```
|
|
|