RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
import { useFetchDefaultModelDictionary } from '@/hooks/use-llm-request';
import { Connection, Node, Position, ReactFlowInstance } from '@xyflow/react';
import humanId from 'human-id';
import { t } from 'i18next';
import { lowerFirst } from 'lodash';
import { useCallback, useMemo } from 'react';
import { useTranslation } from 'react-i18next';
import {
NodeHandleId,
NodeMap,
Operator,
initialAgentValues,
initialArXivValues,
initialBeginValues,
initialBingValues,
initialCategorizeValues,
initialCodeValues,
initialCompilationValues,
initialCrawlerValues,
initialDataOperationsValues,
initialDocGeneratorValues,
initialDuckValues,
initialEmailValues,
initialExeSqlValues,
getInitialExtractorValues,
initialGithubValues,
initialGoogleScholarValues,
initialGoogleValues,
initialInvokeValues,
initialIterationStartValues,
initialIterationValues,
initialKeenableValues,
initialSofyaValues,
initialSearch1APICrawlValues,
initialSearch1APISearchValues,
initialYouComValues,
initialListOperationsValues,
initialLoopValues,
initialMessageValues,
initialNoteValues,
initialPubMedValues,
initialBGPTValues,
initialQueritContentsValues,
initialQueritValues,
initialRetrievalValues,
initialSearXNGValues,
initialStringTransformValues,
initialSwitchValues,
initialTavilyExtractValues,
initialTavilyValues,
initialTitleChunkerValues,
initialTokenChunkerValues,
initialGeneralChunkerValues,
initialTokenizerValues,
initialUserFillUpValues,
initialVariableAggregatorValues,
initialVariableAssignerValues,
initialWaitingDialogueValues,
initialWenCaiValues,
initialWikipediaValues,
initialYahooFinanceValues,
} from '../constant';
import { buildInitialParserValues } from '../form/parser-form/utils';
import useGraphStore from '../store';
import {
generateNodeNamesWithIncreasingIndex,
getNodeDragHandle,
} from '../utils';
function isBottomSubAgent(type: string, position: Position) {
return (
(type === Operator.Agent && position === Position.Bottom) ||
type === Operator.Tool
);
}
// The canvas uses nodeOrigin [0.5, 0], so position.x is a node's horizontal
// center and position.y its top edge.
const DefaultNodeWidth = 200;
const DefaultNodeHeight = 100;
const GroupNodeWidth = 500;
const GroupNodeHeight = 250;
const HorizontalNodeGap = 100;
const VerticalNodeGap = 50;
// Each add must produce a fresh start node object (and id): nodes are stored
// by reference in the zustand store and immer freezes them, so a shared
// object would be frozen after the first add and duplicate ids after the
// second.
const GroupStartNodeBuilders = {
[Operator.Iteration]: (parentId: string): Node<any> => ({
id: `${Operator.IterationStart}:${humanId()}`,
type: 'iterationStartNode',
position: { x: 50, y: 100 },
data: {
label: Operator.IterationStart,
name: Operator.IterationStart,
form: { ...initialIterationStartValues },
},
extent: 'parent' as const,
parentId,
}),
[Operator.Loop]: (parentId: string): Node<any> => ({
id: `${Operator.LoopStart}:${humanId()}`,
type: 'loopStartNode',
position: { x: 50, y: 100 },
data: {
label: Operator.LoopStart,
name: Operator.LoopStart,
form: {},
},
extent: 'parent' as const,
parentId,
}),
};
function useAddGroupNode() {
const { addEdge, addNode } = useGraphStore((state) => state);
const addGroupNode = useCallback(
(
operatorType: string,
newNode: Node<any>,
nodeId?: string,
sourceHandle?: string,
) => {
newNode.width = GroupNodeWidth;
newNode.height = GroupNodeHeight;
const startNode = GroupStartNodeBuilders[
operatorType as keyof typeof GroupStartNodeBuilders
](newNode.id);
addNode(newNode);
addNode(startNode);
if (nodeId) {
addEdge({
source: nodeId,
target: newNode.id,
sourceHandle: sourceHandle || NodeHandleId.Start,
targetHandle: NodeHandleId.End,
});
}
return newNode.id;
},
[addEdge, addNode],
);
return { addGroupNode };
}
export const useInitializeOperatorParams = () => {
const defaultModelDictionary = useFetchDefaultModelDictionary();
const llmId = defaultModelDictionary.llm_id;
const initialFormValuesMap = useMemo(() => {
return {
[Operator.Begin]: initialBeginValues,
[Operator.Retrieval]: initialRetrievalValues,
[Operator.Categorize]: {
...initialCategorizeValues,
llm_id: llmId,
},
[Operator.Message]: initialMessageValues,
[Operator.DuckDuckGo]: initialDuckValues,
[Operator.Wikipedia]: initialWikipediaValues,
[Operator.PubMed]: initialPubMedValues,
[Operator.BGPT]: initialBGPTValues,
[Operator.ArXiv]: initialArXivValues,
[Operator.Google]: initialGoogleValues,
[Operator.Bing]: initialBingValues,
[Operator.GoogleScholar]: initialGoogleScholarValues,
[Operator.SearXNG]: initialSearXNGValues,
[Operator.GitHub]: initialGithubValues,
[Operator.ExeSQL]: initialExeSqlValues,
[Operator.Switch]: initialSwitchValues,
[Operator.WenCai]: initialWenCaiValues,
[Operator.YahooFinance]: initialYahooFinanceValues,
[Operator.Note]: initialNoteValues,
[Operator.Crawler]: initialCrawlerValues,
[Operator.Invoke]: initialInvokeValues,
[Operator.Email]: initialEmailValues,
[Operator.Iteration]: initialIterationValues,
[Operator.IterationStart]: initialIterationStartValues,
[Operator.Code]: initialCodeValues,
[Operator.WaitingDialogue]: initialWaitingDialogueValues,
[Operator.Agent]: { ...initialAgentValues, llm_id: llmId },
[Operator.Tool]: {},
[Operator.TavilySearch]: initialTavilyValues,
[Operator.QueritContents]: initialQueritContentsValues,
[Operator.QueritSearch]: initialQueritValues,
[Operator.KeenableSearch]: initialKeenableValues,
[Operator.YouComSearch]: initialYouComValues,
[Operator.SofyaSearch]: initialSofyaValues,
[Operator.Search1APISearch]: initialSearch1APISearchValues,
[Operator.Search1APICrawl]: initialSearch1APICrawlValues,
[Operator.UserFillUp]: initialUserFillUpValues,
[Operator.StringTransform]: initialStringTransformValues,
[Operator.TavilyExtract]: initialTavilyExtractValues,
[Operator.Placeholder]: {},
[Operator.File]: {},
[Operator.Parser]: buildInitialParserValues(defaultModelDictionary),
[Operator.Tokenizer]: initialTokenizerValues,
[Operator.TokenChunker]: initialTokenChunkerValues,
[Operator.GeneralChunker]: initialGeneralChunkerValues,
[Operator.TitleChunker]: initialTitleChunkerValues,
// The manual chunker shares the title chunker's form (TitleChunkerForm
// with pinMethodGroup) and initial values, like normalizeOperatorForm.
[Operator.ManualChunker]: initialTitleChunkerValues,
// Parser-internal chunkers are never added through the canvas; these
// entries only keep the map exhaustive over Operator.
[Operator.TableChunker]: {},
[Operator.QAChunker]: {},
[Operator.OneChunker]: {},
[Operator.PageChunker]: {},
[Operator.Extractor]: {
...getInitialExtractorValues(),
llm_id: llmId,
},
[Operator.Compiler]: { ...initialCompilationValues, llm_id: llmId },
[Operator.DataOperations]: initialDataOperationsValues,
[Operator.ListOperations]: initialListOperationsValues,
[Operator.VariableAssigner]: initialVariableAssignerValues,
[Operator.VariableAggregator]: initialVariableAggregatorValues,
[Operator.Loop]: initialLoopValues,
[Operator.LoopStart]: {},
[Operator.ExitLoop]: {},
[Operator.DocGenerator]: initialDocGeneratorValues,
[Operator.ExcelProcessor]: {},
} satisfies Record<Operator, unknown>;
}, [defaultModelDictionary, llmId]);
const initializeOperatorParams = useCallback(
(operatorName: Operator, position: Position) => {
const initialValues = initialFormValuesMap[operatorName];
if (isBottomSubAgent(operatorName, position)) {
return {
...initialValues,
description: t('flow.descriptionMessage'),
user_prompt: t('flow.userPromptDefaultValue'),
};
}
return initialValues;
},
[initialFormValuesMap],
);
return { initializeOperatorParams, initialFormValuesMap };
};
export const useGetNodeName = () => {
const { t } = useTranslation();
return (type: string) => {
const name = t(`flow.${lowerFirst(type)}`);
return name;
};
};
export function useCalculateNewlyChildPosition() {
const getNode = useGraphStore((state) => state.getNode);
const nodes = useGraphStore((state) => state.nodes);
const edges = useGraphStore((state) => state.edges);
const calculateNewlyBackChildPosition = useCallback(
(id?: string, sourceHandle?: string, childWidth = DefaultNodeWidth) => {
const parentNode = getNode(id);
// Calculate the coordinates of child nodes to prevent newly added child nodes from covering other child nodes
const allChildNodeIds = edges
.filter((x) => x.source === id && x.sourceHandle === sourceHandle)
.map((x) => x.target);
const childNodes = nodes.filter((x) =>
allChildNodeIds.some((y) => y === x.id),
);
const childTops = childNodes.map((x) => x.position.y);
const childBottoms = childNodes.map(
(x) =>
x.position.y + (x.height ?? x.measured?.height ?? DefaultNodeHeight),
);
// nodeOrigin is [0.5, 0]: position.x is the node's horizontal center,
// so the gap must account for both the parent's and the child's width.
const parentWidth =
parentNode?.width ?? parentNode?.measured?.width ?? DefaultNodeWidth;
const parentRight = (parentNode?.position.x || 0) + parentWidth / 2;
const position = {
y:
childTops.length > 0
? Math.max(
Math.max(...childTops) + 150,
Math.max(...childBottoms) + VerticalNodeGap,
)
: parentNode?.position.y || 0,
x: parentRight + HorizontalNodeGap + childWidth / 2,
};
return position;
},
[edges, getNode, nodes],
);
return { calculateNewlyBackChildPosition };
}
function useAddChildEdge() {
const addEdge = useGraphStore((state) => state.addEdge);
const addChildEdge = useCallback(
(position: Position = Position.Right, edge: Partial<Connection>) => {
if (
position === Position.Right &&
edge.source &&
edge.target &&
edge.sourceHandle
) {
addEdge({
source: edge.source,
target: edge.target,
sourceHandle: edge.sourceHandle,
targetHandle: NodeHandleId.End,
});
}
},
[addEdge],
);
return { addChildEdge };
}
function useAddToolNode() {
const { addEdge, getNode, addNode } = useGraphStore((state) => state);
const addToolNode = useCallback(
(newNode: Node<any>, nodeId?: string): boolean => {
const agentNode = getNode(nodeId);
if (agentNode) {
// Read edges/nodes from the store at call time, not from the
// render-time snapshot: React StrictMode double-invokes the mount
// effect that auto-adds this node (ToolPopover), and the second
// invocation must see the edge the first one just committed —
// otherwise both pass the guard and stack a duplicate tool node at
// the same position.
const { nodes, edges } = useGraphStore.getState();
const childToolNodeIds = edges
.filter(
(x) => x.source === nodeId && x.sourceHandle === NodeHandleId.Tool,
)
.map((x) => x.target);
if (
childToolNodeIds.length > 0 &&
nodes.some((x) => x.id === childToolNodeIds[0])
) {
return false;
}
newNode.position = {
x: agentNode.position.x - 82,
y: agentNode.position.y + 140,
};
addNode(newNode);
if (nodeId) {
addEdge({
source: nodeId,
target: newNode.id,
sourceHandle: NodeHandleId.Tool,
targetHandle: NodeHandleId.End,
});
}
return true;
}
return false;
},
[addEdge, addNode, getNode],
);
return { addToolNode };
}
function useResizeIterationNode() {
const { getNode, nodes, updateNode } = useGraphStore((state) => state);
const resizeIterationNode = useCallback(
(type: string, position: Position, parentId?: string) => {
const parentNode = getNode(parentId);
if (parentNode && !isBottomSubAgent(type, position)) {
const MoveRightDistance = 310;
const childNodeList = nodes.filter((x) => x.parentId === parentId);
const maxX = Math.max(...childNodeList.map((x) => x.position.x));
if (maxX + MoveRightDistance > parentNode.position.x) {
updateNode({
...parentNode,
width: (parentNode.width || 0) + MoveRightDistance,
position: {
x: parentNode.position.x + MoveRightDistance / 2,
y: parentNode.position.y,
},
});
}
}
},
[getNode, nodes, updateNode],
);
return { resizeIterationNode };
}
type CanvasMouseEvent = Pick<
React.MouseEvent<HTMLElement>,
'clientX' | 'clientY'
>;
export function useAddNode(reactFlowInstance?: ReactFlowInstance<any, any>) {
const { edges, nodes, addEdge, addNode, getNode } = useGraphStore(
(state) => state,
);
const getNodeName = useGetNodeName();
const { initializeOperatorParams } = useInitializeOperatorParams();
const { calculateNewlyBackChildPosition } = useCalculateNewlyChildPosition();
const { addChildEdge } = useAddChildEdge();
const { addToolNode } = useAddToolNode();
const { resizeIterationNode } = useResizeIterationNode();
const { addGroupNode } = useAddGroupNode();
// const [reactFlowInstance, setReactFlowInstance] =
// useState<ReactFlowInstance<any, any>>();
const addCanvasNode = useCallback(
(
type: string,
params: {
nodeId?: string;
position: Position;
id?: string;
isFromConnectionDrag?: boolean;
} = {
position: Position.Right,
},
) =>
(event?: CanvasMouseEvent): string | undefined => {
const nodeId = params.nodeId;
const node = getNode(nodeId);
// reactFlowInstance.project was renamed to reactFlowInstance.screenToFlowPosition
// and you don't need to subtract the reactFlowBounds.left/top anymore
// details: https://@xyflow/react.dev/whats-new/2023-11-10
let position = reactFlowInstance?.screenToFlowPosition({
x: event?.clientX || 0,
y: event?.clientY || 0,
});
if (
params.position === Position.Right &&
type !== Operator.Note &&
!params.isFromConnectionDrag
) {
position = calculateNewlyBackChildPosition(
nodeId,
params.id,
[Operator.Iteration, Operator.Loop].includes(type as Operator)
? GroupNodeWidth
: DefaultNodeWidth,
);
}
const newNode: Node<any> = {
id: `${type}:${humanId()}`,
// NodeMap only covers canvas operators; unknown types fall back to
// the generic ragNode renderer.
type: NodeMap[type as keyof typeof NodeMap] || 'ragNode',
position: position || {
x: 0,
y: 0,
},
draggable: type === Operator.Placeholder ? false : undefined,
data: {
label: `${type}`,
name: generateNodeNamesWithIncreasingIndex(
getNodeName(type),
nodes,
),
form: initializeOperatorParams(type as Operator, params.position),
},
sourcePosition: Position.Right,
targetPosition: Position.Left,
dragHandle: getNodeDragHandle(type),
};
if (node && node.parentId) {
newNode.parentId = node.parentId;
newNode.extent = 'parent';
const parentNode = getNode(node.parentId);
if (parentNode && !isBottomSubAgent(type, params.position)) {
resizeIterationNode(type, params.position, node.parentId);
}
}
if ([Operator.Iteration, Operator.Loop].includes(type as Operator)) {
return addGroupNode(type, newNode, nodeId, params.id);
} else if (
type === Operator.Agent &&
params.position === Position.Bottom
) {
const agentNode = getNode(nodeId);
if (agentNode) {
// Calculate the coordinates of child nodes to prevent newly added child nodes from covering other child nodes
const allChildAgentNodeIds = edges
.filter(
(x) =>
x.source === nodeId &&
x.sourceHandle === NodeHandleId.AgentBottom,
)
.map((x) => x.target);
const xAxises = nodes
.filter((x) => allChildAgentNodeIds.some((y) => y === x.id))
.map((x) => x.position.x);
const maxX = Math.max(...xAxises);
newNode.position = {
x: xAxises.length > 0 ? maxX + 262 : agentNode.position.x + 82,
y: agentNode.position.y + 140,
};
}
addNode(newNode);
if (nodeId) {
addEdge({
source: nodeId,
target: newNode.id,
sourceHandle: NodeHandleId.AgentBottom,
targetHandle: NodeHandleId.AgentTop,
});
}
return newNode.id;
} else if (type === Operator.Tool) {
const toolNodeAdded = addToolNode(newNode, params.nodeId);
return toolNodeAdded ? newNode.id : undefined;
} else {
addNode(newNode);
addChildEdge(params.position, {
source: params.nodeId,
target: newNode.id,
sourceHandle: params.id,
});
}
return newNode.id;
},
[
addChildEdge,
addEdge,
addGroupNode,
addNode,
addToolNode,
calculateNewlyBackChildPosition,
edges,
getNode,
getNodeName,
initializeOperatorParams,
nodes,
reactFlowInstance,
resizeIterationNode,
],
);
const addNoteNode = useCallback(
(e: CanvasMouseEvent) => {
addCanvasNode(Operator.Note)(e);
},
[addCanvasNode],
);
return { addCanvasNode, addNoteNode };
}