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
/*
* Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import Image, { AuthenticatedImg } from '@/components/image';
import SvgIcon from '@/components/svg-icon';
import {
MarkdownRemarkPlugins,
MarkdownRemarkPluginsLite,
} from '@/constants/markdown-remark-plugins';
import { IReference, IReferenceChunk } from '@/interfaces/database/chat';
import { citationMarkerReg } from '@/utils/citation-utils';
import { getExtension } from '@/utils/document-util';
import { supportsSourceLocate } from '@/utils/source-locate';
import { getDirAttribute } from '@/utils/text-direction';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import DOMPurify from 'dompurify';
import { memo, useCallback, useEffect, useMemo } from 'react';
import Markdown from 'react-markdown';
import SyntaxHighlighter from 'react-syntax-highlighter';
import rehypeKatex from 'rehype-katex';
import rehypeRaw from 'rehype-raw';
import { RehypeSanitizeAssistantMarkdown } from '@/constants/markdown-rehype-plugins';
import { visitParents } from 'unist-util-visit-parents';
import { useTranslation } from 'react-i18next';
import 'katex/dist/katex.min.css'; // `rehype-katex` does not import the CSS for you
import { useFetchDocumentThumbnailsByIds } from '@/hooks/use-document-request';
import { useLoadingPause } from '@/hooks/use-loading-pause';
import {
decodeAngleBracketEntities,
escapeUnmatchedAngleBrackets,
parseCitationIndex,
preprocessLaTeX,
replaceRetrievingToSection,
replaceTextByOldReg,
replaceThinkToSection,
unescapeAngleBrackets,
} from '@/utils/chat';
import classNames from 'classnames';
import { omit } from 'lodash';
import pipe from 'lodash/fp/pipe';
import reactStringReplace from 'react-string-replace';
import { LoadingDots } from '../loading-dots';
import { Button } from '../ui/button';
import {
HoverCard,
HoverCardContent,
HoverCardTrigger,
} from '../ui/hover-card';
import styles from './index.module.less';
import { sanitizeHtmlWithImagesAsText } from '@/utils/dom-util';
import { SafeImg } from '@/components/safe-img';
const getChunkIndex = (match: string) => parseCitationIndex(match);
const ReferenceMarkerReg = /(\[(?:ID:)?[0-9\u0660-\u0669\u06F0-\u06F9]+\])/g;
// Wraps every text node so citation markers can be replaced by React elements.
// Defined at module scope: react-markdown rebuilds its whole processor whenever
// a plugin's identity changes, and while an answer streams this component
// re-renders many times a second.
const rehypeWrapReference = () => {
return function wrapTextTransform(tree: any) {
visitParents(tree, 'text', (node, ancestors) => {
const latestAncestor = ancestors.at(-1);
if (
latestAncestor.tagName !== 'custom-typography' &&
latestAncestor.tagName !== 'code'
) {
node.type = 'element';
node.tagName = 'custom-typography';
node.properties = {};
node.children = [{ type: 'text', value: node.value }];
}
});
};
};
const MarkdownRehypePlugins = [
rehypeRaw,
RehypeSanitizeAssistantMarkdown,
rehypeWrapReference,
rehypeKatex,
];
const MarkdownParagraph = ({ children, ...props }: any) => (
<p {...props}>{children}</p>
);
const MarkdownCode = (props: any) => {
const { children, className, ...rest } = props;
const restProps = omit(rest, 'node');
const match = /language-(\w+)/.exec(className || '');
// Code content is literal for react-markdown, so the </> entities
// restored by unescapeAngleBrackets survive parsing; decode them back.
const codeText = decodeAngleBracketEntities(String(children));
return match ? (
<SyntaxHighlighter
{...restProps}
PreTag="div"
language={match[1]}
wrapLongLines
>
{codeText.replace(/\n$/, '')}
</SyntaxHighlighter>
) : (
<code {...restProps} className={classNames(className, 'text-wrap')}>
{codeText}
</code>
);
};
// TODO: The display of the table is inconsistent with the display previously placed in the MessageItem.
const MarkdownContent = ({
reference,
clickDocumentButton,
content,
loading,
disableMath = false,
}: {
content: string;
loading: boolean;
reference: IReference;
clickDocumentButton?: (documentId: string, chunk: IReferenceChunk) => void;
/**
* When true, disables LaTeX math rendering (remark-math + rehype-katex).
* Use this for user-generated content where `$` should be treated as literal text.
*/
disableMath?: boolean;
}) => {
const { t } = useTranslation();
const { setDocumentIds, data: fileThumbnails } =
useFetchDocumentThumbnailsByIds();
const contentWithCursor = useMemo(() => {
// Escape standalone < and > outside matched <...> tags
// so DOMPurify doesn't strip them as HTML.
const safeContent = escapeUnmatchedAngleBrackets(content);
let text = DOMPurify.sanitize(safeContent, {
ADD_TAGS: ['think', 'section', 'details', 'summary', 'retrieving'],
ADD_ATTR: ['class'],
});
// let text = content;
if (text === '' && loading) {
text = t('chat.searching');
}
const nextText = replaceTextByOldReg(text);
const thinkSummary = loading
? `${t('chat.thinking')}...`
: t('chat.thought');
return unescapeAngleBrackets(
pipe(
(value: string) => replaceThinkToSection(value, thinkSummary),
replaceRetrievingToSection,
preprocessLaTeX,
// Entity decoding can expose a line-leading > after the first escape.
escapeUnmatchedAngleBrackets,
)(nextText),
);
}, [content, loading, t]);
const documentIds = useMemo(() => {
const docAggs = reference?.doc_aggs;
return Array.isArray(docAggs) ? docAggs.map((x) => x.doc_id) : [];
}, [reference?.doc_aggs]);
// Skipping the empty case matters: this component is mounted once per message,
// and setting a fresh empty array would re-render (and re-parse the markdown
// of) every message that carries no reference at all.
useEffect(() => {
if (documentIds.length === 0) return;
setDocumentIds(documentIds);
}, [documentIds, setDocumentIds]);
const handleDocumentButtonClick = useCallback(
(
documentId: string,
chunk: IReferenceChunk,
fileExtension: string,
documentUrl?: string,
) =>
() => {
if (supportsSourceLocate(fileExtension) && clickDocumentButton) {
clickDocumentButton(documentId, chunk);
return;
}
if (!documentUrl) return;
// Web page documents carry their own url; opening the internal
// /document route for them lands on an empty page.
if (/^https?:\/\//i.test(documentUrl)) {
window.open(documentUrl, '_blank', 'noopener,noreferrer');
return;
}
window.open(
`/document/${documentId}?ext=${fileExtension}&resource=${'document'}`,
'_blank',
);
},
[clickDocumentButton],
);
const getReferenceInfo = useCallback(
(chunkIndex: number) => {
const chunks = reference?.chunks ?? [];
const chunkItem = chunks[chunkIndex];
const document = reference?.doc_aggs?.find(
(x) => x?.doc_id === chunkItem?.document_id,
);
const documentId = document?.doc_id;
const documentUrl = document?.url;
const fileThumbnail = documentId ? fileThumbnails[documentId] : '';
const fileExtension = documentId ? getExtension(document?.doc_name) : '';
const imageId = chunkItem?.image_id;
return {
documentUrl,
fileThumbnail,
fileExtension,
imageId,
chunkItem,
documentId,
document,
};
},
[fileThumbnails, reference],
);
const getPopoverContent = useCallback(
(chunkIndex: number) => {
const {
documentUrl,
fileThumbnail,
fileExtension,
imageId,
chunkItem,
documentId,
document,
} = getReferenceInfo(chunkIndex);
return (
<div key={chunkItem?.id} className="flex gap-2">
{imageId && (
<HoverCard>
<HoverCardTrigger>
<Image
id={imageId}
documentId={documentId}
className={styles.referenceChunkImage}
></Image>
</HoverCardTrigger>
<HoverCardContent>
<Image
id={imageId}
documentId={documentId}
className={styles.referenceImagePreview}
></Image>
</HoverCardContent>
</HoverCard>
)}
<div className={'space-y-2 max-w-[40vw]'}>
<div
dangerouslySetInnerHTML={{
__html: sanitizeHtmlWithImagesAsText(chunkItem?.content ?? ''),
}}
className={classNames(styles.chunkContentText)}
dir="auto"
></div>
{documentId && (
<section className="flex gap-1">
{fileThumbnail ? (
<AuthenticatedImg
src={fileThumbnail}
alt=""
className={styles.fileThumbnail}
/>
) : (
<SvgIcon
name={`file-icon/${fileExtension}`}
width={24}
></SvgIcon>
)}
<Button
variant="link"
className={'text-wrap p-0 flex-1 h-auto'}
onClick={handleDocumentButtonClick(
documentId,
chunkItem,
fileExtension,
documentUrl,
)}
>
{document?.doc_name}
</Button>
</section>
)}
</div>
</div>
);
},
[getReferenceInfo, handleDocumentButtonClick],
);
const renderReference = useCallback(
(text: string) => {
const replacedText = reactStringReplace(
text,
ReferenceMarkerReg,
(match, i) => {
const chunkIndex = getChunkIndex(match);
if (typeof chunkIndex !== 'number') {
return match;
}
const hasReference = !!reference?.chunks?.[chunkIndex];
// Explicit markers can render while their sources are still arriving.
if (!hasReference && !(loading && match.startsWith('[ID:'))) {
return match;
}
return (
<HoverCard key={i}>
<HoverCardTrigger>
<bdi className="text-text-secondary bg-bg-card rounded-2xl px-1 mx-1 text-nowrap inline-block">
[{chunkIndex + 1}]
</bdi>
</HoverCardTrigger>
{hasReference && (
<HoverCardPrimitive.Portal>
<HoverCardContent className="max-w-3xl">
{getPopoverContent(chunkIndex)}
</HoverCardContent>
</HoverCardPrimitive.Portal>
)}
</HoverCard>
);
},
);
return replacedText;
},
[getPopoverContent, loading, reference?.chunks],
);
const dir = getDirAttribute(content.replace(citationMarkerReg, ''));
const showLoadingDots = useLoadingPause(loading, content);
const markdownComponents = useMemo(
() =>
({
p: MarkdownParagraph,
'custom-typography': ({ children }: { children: string }) =>
renderReference(children),
img: SafeImg,
code: MarkdownCode,
}) as any,
[renderReference],
);
return (
<div dir={dir} className={styles.markdownContentWrapper}>
<Markdown
rehypePlugins={
disableMath
? MarkdownRehypePlugins.filter((p) => p !== rehypeKatex)
: MarkdownRehypePlugins
}
remarkPlugins={
disableMath ? MarkdownRemarkPluginsLite : MarkdownRemarkPlugins
}
components={markdownComponents}
>
{contentWithCursor}
</Markdown>
{showLoadingDots && (
<LoadingDots className="ml-1 inline-block text-text-secondary" />
)}
</div>
);
};
export default memo(MarkdownContent);