@lobehub/lobehub 2.0.0-next.98 → 2.0.0-next.99

package/src/tools/index.ts

@@ -4,6 +4,7 @@ import { isDesktop } from '@/const/version';
 
 import { ArtifactsManifest } from './artifacts';
 import { CodeInterpreterManifest } from './code-interpreter';
+import { KnowledgeBaseManifest } from './knowledge-base';
 import { LocalSystemManifest } from './local-system';
 import { WebBrowsingManifest } from './web-browsing';
 
@@ -30,4 +31,10 @@ export const builtinTools: LobeBuiltinTool[] = [
     manifest: CodeInterpreterManifest,
     type: 'builtin',
   },
+  {
+    hidden: true,
+    identifier: KnowledgeBaseManifest.identifier,
+    manifest: KnowledgeBaseManifest,
+    type: 'builtin',
+  },
 ];

package/src/tools/knowledge-base/ExecutionRuntime/index.ts

@@ -0,0 +1,96 @@
+import { formatSearchResults, promptFileContents, promptNoSearchResults } from '@lobechat/prompts';
+import { BuiltinServerRuntimeOutput } from '@lobechat/types';
+
+import { ragService } from '@/services/rag';
+
+import { ReadKnowledgeState, SearchKnowledgeBaseArgs, SearchKnowledgeBaseState } from '../type';
+
+export interface ReadKnowledgeArgs {
+  fileIds: string[];
+}
+
+export class KnowledgeBaseExecutionRuntime {
+  /**
+   * Search knowledge base and return file summaries with relevant chunks
+   */
+  async searchKnowledgeBase(
+    args: SearchKnowledgeBaseArgs,
+    options?: {
+      fileIds?: string[];
+      knowledgeBaseIds?: string[];
+      messageId?: string;
+      signal?: AbortSignal;
+    },
+  ): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const { query, topK = 20 } = args;
+
+      // Call the existing RAG service
+      const { chunks, fileResults } = await ragService.semanticSearchForChat(
+        { fileIds: options?.fileIds, knowledgeIds: options?.knowledgeBaseIds, query, topK },
+        options?.signal,
+      );
+
+      if (chunks.length === 0) {
+        const state: SearchKnowledgeBaseState = { chunks: [], fileResults: [], totalResults: 0 };
+
+        return { content: promptNoSearchResults(query), state, success: true };
+      }
+
+      // Format search results for AI
+      const formattedContent = formatSearchResults(fileResults, query);
+
+      const state: SearchKnowledgeBaseState = { chunks, fileResults, totalResults: chunks.length };
+
+      return { content: formattedContent, state, success: true };
+    } catch (e) {
+      return {
+        content: `Error searching knowledge base: ${(e as Error).message}`,
+        error: e,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Read full content of specific files from knowledge base
+   */
+  async readKnowledge(
+    args: ReadKnowledgeArgs,
+    options?: { signal?: AbortSignal },
+  ): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const { fileIds } = args;
+
+      if (!fileIds || fileIds.length === 0) {
+        return {
+          content: 'Error: No file IDs provided',
+          success: false,
+        };
+      }
+
+      const fileContents = await ragService.getFileContents(fileIds, options?.signal);
+
+      const formattedContent = promptFileContents(fileContents);
+
+      const state: ReadKnowledgeState = {
+        files: fileContents.map((file) => ({
+          error: file.error,
+          fileId: file.fileId,
+          filename: file.filename,
+          preview: file.preview,
+          totalCharCount: file.totalCharCount,
+          totalLineCount: file.totalLineCount,
+        })),
+      };
+
+      return { content: formattedContent, state, success: true };
+    } catch (e) {
+      return {
+        content: `Error reading knowledge: ${(e as Error).message}`,
+        error: e,
+        success: false,
+      };
+    }
+  }
+}

package/src/tools/knowledge-base/Render/ReadKnowledge/FileCard.tsx

@@ -0,0 +1,135 @@
+'use client';
+
+import { Alert, Text } from '@lobehub/ui';
+import { Descriptions } from 'antd';
+import { createStyles } from 'antd-style';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+
+import FileIcon from '@/components/FileIcon';
+
+import { FileContentDetail } from '../../type';
+
+const useStyles = createStyles(({ token, css }) => {
+  return {
+    cardBody: css`
+      padding-block: 12px 8px;
+      padding-inline: 16px;
+    `,
+    container: css`
+      overflow: hidden;
+
+      min-width: 360px;
+      max-width: 360px;
+      border: 1px solid ${token.colorBorderSecondary};
+      border-radius: 12px;
+    `,
+    description: css`
+      margin-block: 0 4px !important;
+      color: ${token.colorTextTertiary};
+    `,
+    footer: css`
+      padding-block: 8px;
+      padding-inline: 16px;
+      border-radius: 8px;
+
+      text-align: center;
+
+      background-color: ${token.colorFillQuaternary};
+    `,
+    footerText: css`
+      font-size: 12px !important;
+      color: ${token.colorTextTertiary} !important;
+    `,
+    icon: css`
+      color: ${token.colorTextSecondary};
+    `,
+    preview: css`
+      overflow: hidden;
+
+      max-height: 80px;
+      padding: 8px;
+      border-radius: 6px;
+
+      font-family: ${token.fontFamilyCode};
+      font-size: 12px;
+      line-height: 1.5;
+      color: ${token.colorTextSecondary};
+    `,
+    title: css`
+      overflow: hidden;
+      display: -webkit-box;
+      -webkit-box-orient: vertical;
+      -webkit-line-clamp: 1;
+
+      margin-block-end: 0;
+    `,
+    titleRow: css`
+      color: ${token.colorText};
+    `,
+  };
+});
+
+interface FileCardProps {
+  file: FileContentDetail;
+}
+
+const FileCard = memo<FileCardProps>(({ file }) => {
+  const { t } = useTranslation('tool');
+  const { styles } = useStyles();
+
+  if (file.error) {
+    return (
+      <Flexbox className={styles.container} gap={8}>
+        <Flexbox className={styles.cardBody} gap={8}>
+          <Flexbox align={'center'} className={styles.titleRow} gap={8} horizontal>
+            <FileIcon fileName={file.filename} size={16} />
+            <div className={styles.title}>{file.filename}</div>
+          </Flexbox>
+        </Flexbox>
+        <div className={styles.footer}>
+          <Alert message={file.error} type={'error'} variant={'borderless'} />
+        </div>
+      </Flexbox>
+    );
+  }
+
+  return (
+    <Flexbox className={styles.container} justify={'space-between'}>
+      <Flexbox className={styles.cardBody} gap={8}>
+        <Flexbox align={'center'} className={styles.titleRow} gap={8} horizontal>
+          <FileIcon fileName={file.filename} size={16} />
+          <div className={styles.title}>{file.filename}</div>
+        </Flexbox>
+        {file.preview && (
+          <Text className={styles.preview} ellipsis={{ rows: 4 }}>
+            {file.preview}...
+          </Text>
+        )}
+      </Flexbox>
+      <div className={styles.footer}>
+        <Descriptions
+          classNames={{
+            content: styles.footerText,
+            label: styles.footerText,
+          }}
+          column={2}
+          items={[
+            {
+              children: file.totalCharCount?.toLocaleString(),
+              label: t('lobe-knowledge-base.readKnowledge.meta.chars'),
+            },
+            {
+              children: file.totalLineCount?.toLocaleString(),
+              label: t('lobe-knowledge-base.readKnowledge.meta.lines'),
+            },
+          ]}
+          size="small"
+        />
+      </div>
+    </Flexbox>
+  );
+});
+
+export default FileCard;

package/src/tools/knowledge-base/Render/ReadKnowledge/index.tsx

@@ -0,0 +1,27 @@
+import { BuiltinRenderProps } from '@lobechat/types';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import { ReadKnowledgeArgs } from '../../ExecutionRuntime';
+import { ReadKnowledgeState } from '../../type';
+import FileCard from './FileCard';
+
+const ReadKnowledge = memo<BuiltinRenderProps<ReadKnowledgeArgs, ReadKnowledgeState>>(
+  ({ pluginState }) => {
+    const { files } = pluginState || {};
+
+    if (!files || files.length === 0) {
+      return null;
+    }
+
+    return (
+      <Flexbox gap={12} horizontal style={{ flexWrap: 'wrap' }}>
+        {files.map((file) => (
+          <FileCard file={file} key={file.fileId} />
+        ))}
+      </Flexbox>
+    );
+  },
+);
+
+export default ReadKnowledge;

package/src/tools/knowledge-base/Render/SearchKnowledgeBase/Item/index.tsx

@@ -0,0 +1,54 @@
+import { FileSearchResult } from '@lobechat/types';
+import { Text, Tooltip } from '@lobehub/ui';
+import { memo } from 'react';
+import { Center, Flexbox } from 'react-layout-kit';
+
+import FileIcon from '@/components/FileIcon';
+import { useIsMobile } from '@/hooks/useIsMobile';
+import { useChatStore } from '@/store/chat';
+
+import { useStyles } from './style';
+
+export interface FileItemProps extends FileSearchResult {
+  index: number;
+}
+
+const FileItem = memo<FileItemProps>(({ fileId, fileName, relevanceScore, topChunks }) => {
+  const { styles, cx } = useStyles();
+  const openFilePreview = useChatStore((s) => s.openFilePreview);
+
+  const isMobile = useIsMobile();
+
+  // Use the first chunk for preview
+  const firstChunk = topChunks[0];
+
+  return (
+    <Flexbox
+      align={'center'}
+      className={cx(styles.container, isMobile && styles.mobile)}
+      gap={4}
+      horizontal
+      key={fileId}
+      onClick={(e) => {
+        e.stopPropagation();
+        if (firstChunk) {
+          openFilePreview({
+            chunkId: firstChunk.id,
+            chunkText: firstChunk.text,
+            fileId,
+          });
+        }
+      }}
+    >
+      <FileIcon fileName={fileName} size={20} variant={'raw'} />
+      <Flexbox gap={12} horizontal justify={'space-between'} style={{ maxWidth: 200 }}>
+        <Text ellipsis>{fileName}</Text>
+        <Tooltip title={`Relevance: ${(relevanceScore * 100).toFixed(1)}%`}>
+          <Center className={styles.badge}>{relevanceScore.toFixed(2)}</Center>
+        </Tooltip>
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default FileItem;

package/src/tools/knowledge-base/Render/SearchKnowledgeBase/Item/style.ts

@@ -0,0 +1,51 @@
+import { createStyles } from 'antd-style';
+import { lighten } from 'polished';
+
+export const useStyles = createStyles(({ css, token, isDarkMode }) => ({
+  badge: css`
+    padding-block: 4px;
+    padding-inline: 6px;
+    border-radius: 2222px;
+
+    font-size: 12px;
+    line-height: 12px;
+    color: ${token.colorTextSecondary};
+
+    background: ${token.colorFillSecondary};
+  `,
+
+  container: css`
+    cursor: pointer;
+
+    width: fit-content;
+    padding-block: 6px;
+    padding-inline: 8px;
+    padding-inline-end: 12px;
+    border-radius: 8px;
+
+    color: ${token.colorText};
+
+    background: ${lighten(0.1, token.colorBgElevated)};
+    box-shadow: ${token.boxShadowTertiary};
+
+    transition: all 0.2s;
+
+    &:hover {
+      background: ${isDarkMode ? lighten(0.15, token.colorBgElevated) : ''};
+      box-shadow: ${token.boxShadowSecondary};
+    }
+  `,
+  filename: css`
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 1;
+
+    font-size: 12px;
+    text-overflow: ellipsis;
+  `,
+
+  mobile: css`
+    width: 100%;
+  `,
+}));

package/src/tools/knowledge-base/Render/SearchKnowledgeBase/index.tsx

@@ -0,0 +1,23 @@
+import { BuiltinRenderProps } from '@lobechat/types';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import { SearchKnowledgeBaseArgs, SearchKnowledgeBaseState } from '@/tools/knowledge-base/type';
+
+import FileItem from './Item';
+
+const SearchKnowledgeBase = memo<
+  BuiltinRenderProps<SearchKnowledgeBaseArgs, SearchKnowledgeBaseState>
+>(({ pluginState }) => {
+  const { fileResults } = pluginState || {};
+
+  return (
+    <Flexbox gap={8} horizontal wrap={'wrap'}>
+      {fileResults?.map((file, index) => {
+        return <FileItem index={index} key={file.fileId} {...file} />;
+      })}
+    </Flexbox>
+  );
+});
+
+export default SearchKnowledgeBase;

package/src/tools/knowledge-base/Render/index.ts

@@ -0,0 +1,7 @@
+import ReadKnowledge from './ReadKnowledge';
+import SearchKnowledgeBase from './SearchKnowledgeBase';
+
+export const KnowledgeBaseRenders = {
+  readKnowledge: ReadKnowledge,
+  searchKnowledgeBase: SearchKnowledgeBase,
+};

package/src/tools/knowledge-base/index.ts

@@ -0,0 +1,64 @@
+import { BuiltinToolManifest } from '@lobechat/types';
+
+import { systemPrompt } from './systemRole';
+
+export const KnowledgeBaseApiName = {
+  readKnowledge: 'readKnowledge',
+  searchKnowledgeBase: 'searchKnowledgeBase',
+};
+
+export const KnowledgeBaseManifest: BuiltinToolManifest = {
+  api: [
+    {
+      description:
+        'Search through knowledge base using semantic vector search to find relevant files and chunks. Returns a summary of matching files with their relevance scores and brief excerpts. Use this first to discover which files contain relevant information. IMPORTANT: Since this uses vector-based search, always resolve pronouns and references to concrete entities (e.g., use "authentication system" instead of "it").',
+      name: KnowledgeBaseApiName.searchKnowledgeBase,
+      parameters: {
+        properties: {
+          query: {
+            description:
+              'The search query to find relevant information. Be specific and use concrete entities. IMPORTANT: Resolve all pronouns and references (like "it", "that", "this") to actual entity names before searching, as this uses semantic vector search which works best with concrete terms.',
+            type: 'string',
+          },
+          topK: {
+            default: 15,
+            description:
+              'Number of top relevant chunks to return (default: 15). Each file will include the most relevant chunks.',
+            maximum: 100,
+            minimum: 5,
+            type: 'number',
+          },
+        },
+        required: ['query'],
+        type: 'object',
+      },
+    },
+    {
+      description:
+        'Read the full content of specific files from the knowledge base. Use this after searchKnowledgeBase to get complete information from relevant files. You can read multiple files at once.',
+      name: KnowledgeBaseApiName.readKnowledge,
+      parameters: {
+        properties: {
+          fileIds: {
+            description:
+              'Array of file IDs to read. Get these IDs from searchKnowledgeBase results.',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        required: ['fileIds'],
+        type: 'object',
+      },
+    },
+  ],
+  identifier: 'lobe-knowledge-base',
+  meta: {
+    avatar: '📚',
+    description: 'Search and retrieve information from knowledge bases',
+    title: 'Knowledge Base',
+  },
+  systemRole: systemPrompt,
+  type: 'builtin',
+};

package/src/tools/knowledge-base/systemRole.ts

@@ -0,0 +1,102 @@
+export const systemPrompt = `You have access to a Knowledge Base tool with powerful semantic search and document retrieval capabilities. You can search through knowledge bases to find relevant information and read the full content of files.
+
+<core_capabilities>
+1. Search through knowledge base using semantic search (searchKnowledgeBase)
+2. Read the full content of specific files from the knowledge base (readKnowledge)
+</core_capabilities>
+
+<workflow>
+1. Understand the user's information need or question
+2. Formulate a clear, specific search query
+3. Use searchKnowledgeBase to discover relevant files and chunks
+4. Review search results to identify the most relevant files
+5. Use readKnowledge to retrieve full content from selected files
+6. Synthesize information and answer the user's question
+7. Always cite source files when providing information
+</workflow>
+
+<tool_selection_guidelines>
+- **searchKnowledgeBase**: Use this first to discover which files contain relevant information
+  - Uses semantic vector search to find relevant content
+  - Returns file names, relevance scores, and brief excerpts
+  - Helps you decide which files to read in full
+  - You can adjust topK parameter (5-100, default: 15) based on how many results you need
+  - **IMPORTANT**: Since this uses vector-based semantic search, always resolve references and use concrete entities in your query
+    - BAD: "What does it do?" or "Tell me about that feature"
+    - GOOD: "What does the authentication system do?" or "Tell me about the JWT authentication feature"
+
+- **readKnowledge**: Use this after searching to get complete file content
+  - Can read multiple files at once by providing their file IDs
+  - Get file IDs from searchKnowledgeBase results
+  - Provides complete context from the selected files
+</tool_selection_guidelines>
+
+<search_strategy_guidelines>
+- **Coreference Resolution**: Always resolve pronouns and references to concrete entities before searching
+  - Replace "it", "that", "this", "them" with the actual entity names
+  - Use full names instead of abbreviations when first searching
+  - Include relevant context in the query itself
+  - Examples:
+    - User asks: "What are its features?" (after discussing "authentication system")
+    - Search query should be: "authentication system features" (NOT "its features")
+    - User asks: "How does that work?"
+    - Search query should include the specific topic being discussed
+- Formulate clear and specific search queries that capture the core information need
+- For broad topics, start with a general query then refine if needed
+- For specific questions, use precise terminology
+- You can perform multiple searches with different queries or perspectives if needed
+- Adjust topK based on result quality - increase if you need more context, decrease for focused searches
+- Review the relevance scores and excerpts to select the most pertinent files
+</search_strategy_guidelines>
+
+<reading_strategy_guidelines>
+- Read only the files that are most relevant to avoid information overload
+- You can read multiple files at once if they all contain relevant information
+- Prioritize files with higher relevance scores from search results
+- If search results show many relevant files, consider reading them in batches
+</reading_strategy_guidelines>
+
+<citation_requirements>
+- Always cite the source files when providing information
+- Reference file names clearly in your response
+- If specific information comes from a particular file, mention it explicitly
+- Help users understand which knowledge base files support your answers
+</citation_requirements>
+
+<response_format>
+When providing information from the knowledge base:
+1. Start with a direct answer to the user's question when possible
+2. Provide relevant details and context from the knowledge base files
+3. Clearly cite which files the information comes from
+4. If information is insufficient or not found, inform the user clearly
+5. Suggest related searches if the initial search doesn't yield good results
+</response_format>
+
+<best_practices>
+- Always start with searchKnowledgeBase before reading files
+- Don't read files blindly - review search results first
+- Be selective about which files to read based on relevance
+- If no relevant information is found, clearly inform the user
+- Suggest alternative search queries if initial results are poor
+- Respect the knowledge base's scope - it may not contain all information
+- Combine information from multiple files when appropriate
+- Maintain accuracy - only cite information actually present in the files
+</best_practices>
+
+<error_handling>
+- If search returns no results:
+  1. Try reformulating the query with different keywords or broader terms
+  2. Suggest alternative search approaches to the user
+  3. Inform the user if the topic appears to be outside the knowledge base's scope
+
+- If file reading fails:
+  1. Inform the user which files couldn't be accessed
+  2. Work with successfully retrieved files if any
+  3. Suggest searching again if necessary
+
+- If search results are ambiguous:
+  1. Ask for clarification from the user
+  2. Provide a summary of what types of information were found
+  3. Let the user guide which direction to explore further
+</error_handling>
+`;

package/src/tools/knowledge-base/type.ts

@@ -0,0 +1,25 @@
+import { ChatSemanticSearchChunk, FileSearchResult } from '@lobechat/types';
+
+
+export interface SearchKnowledgeBaseArgs {
+  query: string;
+  topK?: number;
+}
+export interface SearchKnowledgeBaseState {
+  chunks: ChatSemanticSearchChunk[];
+  fileResults: FileSearchResult[];
+  totalResults: number;
+}
+
+export interface FileContentDetail {
+  error?: string;
+  fileId: string;
+  filename: string;
+  preview?: string;
+  totalCharCount?: number;
+  totalLineCount?: number;
+}
+
+export interface ReadKnowledgeState {
+  files: FileContentDetail[];
+}

package/src/tools/local-system/Intervention/WriteFile/index.tsx

@@ -11,7 +11,7 @@ import { LocalFile, LocalFolder } from '@/features/LocalFile';
 
 const WriteFile = memo<BuiltinInterventionProps<WriteLocalFileParams>>(({ args }) => {
   const { t } = useTranslation('tool');
-  const { base, dir, ext } = path.parse(args.path);
+  const { base, dir, ext } = path.parse(args.path || '');
 
   // Detect language from file extension
   const language = useMemo(() => {

package/src/tools/renders.ts

@@ -2,6 +2,9 @@ import { BuiltinRender } from '@lobechat/types';
 
 import { CodeInterpreterManifest } from './code-interpreter';
 import CodeInterpreterRender from './code-interpreter/Render';
+// knowledge-base
+import { KnowledgeBaseManifest } from './knowledge-base';
+import { KnowledgeBaseRenders } from './knowledge-base/Render';
 // local-system
 import { LocalSystemManifest } from './local-system';
 import { LocalSystemRenders } from './local-system/Render';
@@ -16,6 +19,7 @@ import { WebBrowsingRenders } from './web-browsing/Render';
 const BuiltinToolsRenders: Record<string, Record<string, BuiltinRender>> = {
   [LocalSystemManifest.identifier]: LocalSystemRenders as Record<string, BuiltinRender>,
   [WebBrowsingManifest.identifier]: WebBrowsingRenders as Record<string, BuiltinRender>,
+  [KnowledgeBaseManifest.identifier]: KnowledgeBaseRenders as Record<string, BuiltinRender>,
   [CodeInterpreterManifest.identifier]: {
     python: CodeInterpreterRender as BuiltinRender,
   },

package/src/store/chat/agents/createToolEngine.ts

@@ -1,22 +0,0 @@
-import { WorkingModel } from '@lobechat/types';
-
-import { getSearchConfig } from '@/helpers/getSearchConfig';
-import { createToolsEngine } from '@/helpers/toolEngineering';
-import { WebBrowsingManifest } from '@/tools/web-browsing';
-
-export const createAgentToolsEngine = (workingModel: WorkingModel) =>
-  createToolsEngine({
-    // Add WebBrowsingManifest as default tool
-    defaultToolIds: [WebBrowsingManifest.identifier],
-    // Create search-aware enableChecker for this request
-    enableChecker: ({ pluginId }) => {
-      // For WebBrowsingManifest, apply search logic
-      if (pluginId === WebBrowsingManifest.identifier) {
-        const searchConfig = getSearchConfig(workingModel.model, workingModel.provider);
-        return searchConfig.useApplicationBuiltinSearchTool;
-      }
-
-      // For all other plugins, enable by default
-      return true;
-    },
-  });