Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

11.0 KB
Raw Blame
import { ActivepiecesError, ApMultipartFile, ErrorCode, isMultipartFile, Permission } from '@activepieces/core-utils'
import { EMBEDDING_DIMENSIONS } from '@activepieces/server-utils'
import { KnowledgeBaseEmbeddingSource, PrincipalType, SERVICE_KEY_SECURITY_OPENAPI } from '@activepieces/shared'
import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { StatusCodes } from 'http-status-codes'
import { z } from 'zod'
import { ProjectResourceType } from '../core/security/authorization/common'
import { securityAccess } from '../core/security/authorization/fastify-security'
import { attachMultipartFieldsToBody } from '../helper/multipart-body'
import { knowledgeBaseService } from './knowledge-base.service'

const KB_PRINCIPALS = [PrincipalType.USER, PrincipalType.ENGINE, PrincipalType.SERVICE] as const
const KB_ALLOWED_MIME_TYPES = ['application/pdf', 'text/plain', 'text/csv', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']

export const knowledgeBaseController: FastifyPluginAsyncZod = async (fastify) => {

    fastify.post('/', CreateKnowledgeBaseFileRequest, async (request, reply) => {
        const result = await knowledgeBaseService(request.log).createFile({
            projectId: request.projectId,
            fileId: request.body.fileId,
            displayName: request.body.displayName,
        })
        return reply.status(StatusCodes.CREATED).send(result)
    })

    fastify.post('/upload', UploadKnowledgeBaseFileRequest, async (request, reply) => {
        const { file, displayName } = request.body
        if (!isMultipartFile(file)) {
            throw new ActivepiecesError({
                code: ErrorCode.VALIDATION,
                params: {
                    message: 'File is required',
                },
            })
        }
        if (!KB_ALLOWED_MIME_TYPES.includes(file.mimetype ?? '')) {
            throw new ActivepiecesError({
                code: ErrorCode.VALIDATION,
                params: {
                    message: `Invalid file type. Allowed types: ${KB_ALLOWED_MIME_TYPES.join(', ')}`,
                },
            })
        }

        const service = knowledgeBaseService(request.log)
        const embedFn = await service.embedderFor({ projectId: request.projectId, platformId: request.principal.platform.id })
        const kbFile = await service.uploadFile({ projectId: request.projectId, data: file.data, fileName: file.filename, displayName, embedFn })

        return reply.status(StatusCodes.CREATED).send(kbFile)
    })

    fastify.get('/', ListKnowledgeBaseFilesRequest, async (request) => {
        return knowledgeBaseService(request.log).listFiles({
            projectId: request.projectId,
        })
    })

    fastify.get('/embedding-source', GetEmbeddingSourceRequest, async (request) => {
        return knowledgeBaseService(request.log).getEmbeddingSource({
            projectId: request.projectId,
            platformId: request.principal.platform.id,
        })
    })

    fastify.delete('/:id', DeleteKnowledgeBaseFileRequest, async (request, reply) => {
        await knowledgeBaseService(request.log).deleteFile({
            projectId: request.projectId,
            id: request.params.id,
        })
        return reply.status(StatusCodes.NO_CONTENT).send()
    })

    fastify.get('/:id/chunks/count', GetChunkCountRequest, async (request) => {
        const count = await knowledgeBaseService(request.log).getChunkCount({
            projectId: request.projectId,
            knowledgeBaseFileId: request.params.id,
        })
        return { count }
    })

    fastify.post('/:id/extract-chunks', ExtractChunksRequest, async (request) => {
        const chunks = await knowledgeBaseService(request.log).extractChunks({
            projectId: request.projectId,
            knowledgeBaseFileId: request.params.id,
        })
        return { chunks }
    })

    fastify.post('/:id/store-chunks', StoreChunksRequest, async (request) => {
        await knowledgeBaseService(request.log).storeChunks({
            projectId: request.projectId,
            knowledgeBaseFileId: request.params.id,
            chunks: request.body.chunks,
        })
        return { success: true }
    })

    fastify.get('/:id/chunks', ListChunksRequest, async (request) => {
        return knowledgeBaseService(request.log).listChunks({
            projectId: request.projectId,
            knowledgeBaseFileId: request.params.id,
            embedded: request.query.embedded !== undefined ? request.query.embedded === 'true' : undefined,
        })
    })

    fastify.post('/search', SearchKnowledgeBaseRequest, async (request) => {
        return knowledgeBaseService(request.log).search({
            projectId: request.projectId,
            knowledgeBaseFileIds: request.body.knowledgeBaseFileIds,
            queryEmbedding: request.body.queryEmbedding,
            limit: request.body.limit ?? 5,
            similarityThreshold: request.body.similarityThreshold,
        })
    })
}

const CreateKnowledgeBaseFileRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.WRITE_KNOWLEDGE_BASE, {
            type: ProjectResourceType.BODY,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Register a file for knowledge base ingestion',
        body: z.object({
            fileId: z.string(),
            displayName: z.string(),
        }),
        response: {
            [StatusCodes.CREATED]: z.object({
                id: z.string(),
            }),
        },
    },
}

const UploadKnowledgeBaseFileRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.WRITE_KNOWLEDGE_BASE, {
            type: ProjectResourceType.QUERY,
        }),
    },
    // The whole body is consumed up front so `displayName` is found regardless of whether the
    // client appends it before or after the file part — reading it off the file part's `fields`
    // only sees fields that happened to arrive first.
    preValidation: attachMultipartFieldsToBody,
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        consumes: ['multipart/form-data'],
        description: 'Upload a file and create a knowledge base file record',
        body: z.object({
            file: ApMultipartFile,
            displayName: z.string(),
        }),
        querystring: z.object({
            projectId: z.string(),
        }),
    },
}

const ListKnowledgeBaseFilesRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.READ_KNOWLEDGE_BASE, {
            type: ProjectResourceType.QUERY,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'List knowledge base files for the project',
        querystring: z.object({
            projectId: z.string(),
        }),
    },
}

const GetEmbeddingSourceRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.READ_KNOWLEDGE_BASE, {
            type: ProjectResourceType.QUERY,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'The AI provider and model that embed this project\'s knowledge base files, or null when none can',
        querystring: z.object({
            projectId: z.string(),
        }),
        response: {
            [StatusCodes.OK]: KnowledgeBaseEmbeddingSource,
        },
    },
}

const DeleteKnowledgeBaseFileRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.WRITE_KNOWLEDGE_BASE, {
            type: ProjectResourceType.QUERY,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Delete a knowledge base file and all its chunks',
        params: z.object({
            id: z.string(),
        }),
        querystring: z.object({
            projectId: z.string(),
        }),
    },
}

const GetChunkCountRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.READ_KNOWLEDGE_BASE, {
            type: ProjectResourceType.PARAM,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Get the number of chunks for a knowledge base file',
        params: z.object({
            id: z.string(),
        }),
    },
}

const ExtractChunksRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.WRITE_KNOWLEDGE_BASE, {
            type: ProjectResourceType.PARAM,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Extract text chunks from a knowledge base file',
        params: z.object({
            id: z.string(),
        }),
    },
}

const StoreChunksRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.WRITE_KNOWLEDGE_BASE, {
            type: ProjectResourceType.PARAM,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Store or update chunks for a knowledge base file. Provide id to update existing chunks, or content to create new ones.',
        params: z.object({
            id: z.string(),
        }),
        body: z.object({
            chunks: z.array(z.object({
                id: z.string().optional(),
                content: z.string().optional(),
                embedding: z.array(z.number()).length(EMBEDDING_DIMENSIONS).optional(),
                chunkIndex: z.number().optional(),
                metadata: z.record(z.string(), z.unknown()).optional(),
            })),
        }),
    },
}

const ListChunksRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.READ_KNOWLEDGE_BASE, {
            type: ProjectResourceType.PARAM,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'List chunks for a knowledge base file, optionally filtered by embedding status',
        params: z.object({
            id: z.string(),
        }),
        querystring: z.object({
            embedded: z.enum(['true', 'false']).optional(),
        }),
    },
}

const SearchKnowledgeBaseRequest = {
    config: {
        security: securityAccess.project(KB_PRINCIPALS, Permission.READ_KNOWLEDGE_BASE, {
            type: ProjectResourceType.BODY,
        }),
    },
    schema: {
        tags: ['knowledge-base'],
        security: [SERVICE_KEY_SECURITY_OPENAPI],
        description: 'Search knowledge base using vector similarity',
        body: z.object({
            knowledgeBaseFileIds: z.array(z.string()),
            queryEmbedding: z.array(z.number()).length(EMBEDDING_DIMENSIONS),
            limit: z.number().int().min(1).max(100).optional().default(5),
            similarityThreshold: z.number().min(0).max(1).optional(),
        }),
    },
}