feat: knowledge directory

backend/open_webui/migrations/versions/3c9b0ca343fd_add_knowledge_directory_table.py

@@ -0,0 +1,62 @@
+"""add knowledge_directory table
+
+Revision ID: 3c9b0ca343fd
+Revises: a0b1c2d3e4f5
+Create Date: 2026-05-13 21:58:40.832482
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '3c9b0ca343fd'
+down_revision: Union[str, None] = 'a0b1c2d3e4f5'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create knowledge_directory table
+    op.create_table(
+        'knowledge_directory',
+        sa.Column('id', sa.Text(), nullable=False),
+        sa.Column('knowledge_id', sa.Text(), nullable=False),
+        sa.Column('parent_id', sa.Text(), nullable=True),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('user_id', sa.Text(), nullable=False),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
+        sa.ForeignKeyConstraint(['knowledge_id'], ['knowledge.id'], ondelete='CASCADE'),
+        sa.ForeignKeyConstraint(['parent_id'], ['knowledge_directory.id'], ondelete='CASCADE'),
+        sa.PrimaryKeyConstraint('id'),
+        sa.UniqueConstraint('knowledge_id', 'parent_id', 'name', name='uq_knowledge_directory_knowledge_parent_name'),
+    )
+    op.create_index('ix_knowledge_directory_knowledge_id', 'knowledge_directory', ['knowledge_id'])
+    op.create_index('ix_knowledge_directory_parent_id', 'knowledge_directory', ['parent_id'])
+
+    # Add directory_id column to knowledge_file
+    with op.batch_alter_table('knowledge_file') as batch:
+        batch.add_column(sa.Column('directory_id', sa.Text(), nullable=True))
+        batch.create_foreign_key(
+            'fk_knowledge_file_directory_id',
+            'knowledge_directory',
+            ['directory_id'],
+            ['id'],
+            ondelete='SET NULL',
+        )
+        batch.create_index('ix_knowledge_file_directory_id', ['directory_id'])
+
+
+def downgrade() -> None:
+    # Remove directory_id from knowledge_file
+    with op.batch_alter_table('knowledge_file') as batch:
+        batch.drop_index('ix_knowledge_file_directory_id')
+        batch.drop_constraint('fk_knowledge_file_directory_id', type_='foreignkey')
+        batch.drop_column('directory_id')
+
+    # Drop knowledge_directory table
+    op.drop_index('ix_knowledge_directory_parent_id', table_name='knowledge_directory')
+    op.drop_index('ix_knowledge_directory_knowledge_id', table_name='knowledge_directory')
+    op.drop_table('knowledge_directory')

backend/open_webui/models/knowledge.py

@@ -20,6 +20,7 @@ from sqlalchemy import (
     BigInteger,
     Column,
     ForeignKey,
+    Index,
     String,
     Text,
     UniqueConstraint,
@@ -56,6 +57,25 @@ class Knowledge(Base):
     updated_at = Column(BigInteger)
 
 
+class KnowledgeDirectory(Base):
+    __tablename__ = 'knowledge_directory'
+
+    id = Column(Text, unique=True, primary_key=True)
+    knowledge_id = Column(Text, ForeignKey('knowledge.id', ondelete='CASCADE'), nullable=False)
+    parent_id = Column(Text, ForeignKey('knowledge_directory.id', ondelete='CASCADE'), nullable=True)
+    name = Column(Text, nullable=False)
+    user_id = Column(Text, nullable=False)
+
+    created_at = Column(BigInteger, nullable=False)
+    updated_at = Column(BigInteger, nullable=False)
+
+    __table_args__ = (
+        UniqueConstraint('knowledge_id', 'parent_id', 'name', name='uq_knowledge_directory_knowledge_parent_name'),
+        Index('ix_knowledge_directory_knowledge_id', 'knowledge_id'),
+        Index('ix_knowledge_directory_parent_id', 'parent_id'),
+    )
+
+
 class KnowledgeModel(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
@@ -80,18 +100,23 @@ class KnowledgeFile(Base):
 
     knowledge_id = Column(Text, ForeignKey('knowledge.id', ondelete='CASCADE'), nullable=False)
     file_id = Column(Text, ForeignKey('file.id', ondelete='CASCADE'), nullable=False)
+    directory_id = Column(Text, ForeignKey('knowledge_directory.id', ondelete='SET NULL'), nullable=True)
     user_id = Column(Text, nullable=False)
 
     created_at = Column(BigInteger, nullable=False)
     updated_at = Column(BigInteger, nullable=False)
 
-    __table_args__ = (UniqueConstraint('knowledge_id', 'file_id', name='uq_knowledge_file_knowledge_file'),)
+    __table_args__ = (
+        UniqueConstraint('knowledge_id', 'file_id', name='uq_knowledge_file_knowledge_file'),
+        Index('ix_knowledge_file_directory_id', 'directory_id'),
+    )
 
 
 class KnowledgeFileModel(BaseModel):
     id: str
     knowledge_id: str
     file_id: str
+    directory_id: Optional[str] = None
     user_id: str
 
     created_at: int  # timestamp in epoch
@@ -100,6 +125,24 @@ class KnowledgeFileModel(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
 
+class KnowledgeDirectoryModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str
+    knowledge_id: str
+    parent_id: Optional[str] = None
+    name: str
+    user_id: str
+
+    created_at: int  # timestamp in epoch
+    updated_at: int  # timestamp in epoch
+
+
+class KnowledgeDirectoryForm(BaseModel):
+    name: str
+    parent_id: Optional[str] = None
+
+
 ####################
 # Forms
 ####################
@@ -132,6 +175,8 @@ class KnowledgeListResponse(BaseModel):
 
 class KnowledgeFileListResponse(BaseModel):
     items: list[FileUserResponse]
+    directories: list[KnowledgeDirectoryModel] = Field(default_factory=list)
+    breadcrumbs: list[KnowledgeDirectoryModel] = Field(default_factory=list)
     total: int
 
 
@@ -468,6 +513,14 @@ class KnowledgeTable:
                     .filter(KnowledgeFile.knowledge_id == knowledge_id)
                 )
 
+                # Filter by directory_id (None = root level)
+                directory_id = filter.get('directory_id') if filter else None
+                if directory_id:
+                    stmt = stmt.filter(KnowledgeFile.directory_id == directory_id)
+                elif filter and 'directory_id' in filter:
+                    # Explicit None = root level only
+                    stmt = stmt.filter(KnowledgeFile.directory_id.is_(None))
+
                 # Default sort: updated_at descending
                 primary_sort = File.updated_at.desc()
 
@@ -522,7 +575,19 @@ class KnowledgeTable:
                         )
                     )
 
-                return KnowledgeFileListResponse(items=files, total=total)
+                return KnowledgeFileListResponse(
+                    items=files,
+                    directories=await self.get_directories(
+                        knowledge_id,
+                        parent_id=filter.get('directory_id') if filter else None,
+                        db=db,
+                    ),
+                    breadcrumbs=await self.get_directory_breadcrumbs(
+                        filter.get('directory_id') if filter else None,
+                        db=db,
+                    ),
+                    total=total,
+                )
         except Exception as e:
             print(e)
             return KnowledgeFileListResponse(items=[], total=0)
@@ -554,6 +619,7 @@ class KnowledgeTable:
         knowledge_id: str,
         file_id: str,
         user_id: str,
+        directory_id: Optional[str] = None,
         db: Optional[AsyncSession] = None,
     ) -> Optional[KnowledgeFileModel]:
         async with get_async_db_context(db) as db:
@@ -562,6 +628,7 @@ class KnowledgeTable:
                     'id': str(uuid.uuid4()),
                     'knowledge_id': knowledge_id,
                     'file_id': file_id,
+                    'directory_id': directory_id,
                     'user_id': user_id,
                     'created_at': int(time.time()),
                     'updated_at': int(time.time()),
@@ -686,5 +753,269 @@ class KnowledgeTable:
             except Exception:
                 return False
 
+    # ── Directory CRUD ────────────────────────────────────────────────
+
+    async def create_directory(
+        self,
+        knowledge_id: str,
+        name: str,
+        user_id: str,
+        parent_id: Optional[str] = None,
+        db: Optional[AsyncSession] = None,
+    ) -> Optional[KnowledgeDirectoryModel]:
+        async with get_async_db_context(db) as db:
+            try:
+                now = int(time.time())
+                directory = KnowledgeDirectory(
+                    id=str(uuid.uuid4()),
+                    knowledge_id=knowledge_id,
+                    parent_id=parent_id,
+                    name=name,
+                    user_id=user_id,
+                    created_at=now,
+                    updated_at=now,
+                )
+                db.add(directory)
+                await db.commit()
+                await db.refresh(directory)
+                return KnowledgeDirectoryModel.model_validate(directory)
+            except Exception as e:
+                log.exception(e)
+                return None
+
+    async def get_directories(
+        self,
+        knowledge_id: str,
+        parent_id: Optional[str] = None,
+        db: Optional[AsyncSession] = None,
+    ) -> list[KnowledgeDirectoryModel]:
+        """List directories at a given level (parent_id=None for root)."""
+        async with get_async_db_context(db) as db:
+            stmt = select(KnowledgeDirectory).filter(
+                KnowledgeDirectory.knowledge_id == knowledge_id
+            )
+            if parent_id:
+                stmt = stmt.filter(KnowledgeDirectory.parent_id == parent_id)
+            else:
+                stmt = stmt.filter(KnowledgeDirectory.parent_id.is_(None))
+
+            stmt = stmt.order_by(KnowledgeDirectory.name.asc())
+            result = await db.execute(stmt)
+            return [KnowledgeDirectoryModel.model_validate(d) for d in result.scalars().all()]
+
+    async def get_directory_by_id(
+        self, directory_id: str, db: Optional[AsyncSession] = None
+    ) -> Optional[KnowledgeDirectoryModel]:
+        async with get_async_db_context(db) as db:
+            result = await db.execute(
+                select(KnowledgeDirectory).filter_by(id=directory_id)
+            )
+            directory = result.scalars().first()
+            return KnowledgeDirectoryModel.model_validate(directory) if directory else None
+
+    async def get_directory_breadcrumbs(
+        self,
+        directory_id: Optional[str],
+        db: Optional[AsyncSession] = None,
+    ) -> list[KnowledgeDirectoryModel]:
+        """Walk up the parent chain to build breadcrumbs (root first)."""
+        if not directory_id:
+            return []
+
+        async with get_async_db_context(db) as db:
+            breadcrumbs = []
+            current_id = directory_id
+            seen = set()
+
+            while current_id and current_id not in seen:
+                seen.add(current_id)
+                result = await db.execute(
+                    select(KnowledgeDirectory).filter_by(id=current_id)
+                )
+                directory = result.scalars().first()
+                if not directory:
+                    break
+                breadcrumbs.append(KnowledgeDirectoryModel.model_validate(directory))
+                current_id = directory.parent_id
+
+            breadcrumbs.reverse()  # root first
+            return breadcrumbs
+
+    async def rename_directory(
+        self,
+        directory_id: str,
+        name: str,
+        db: Optional[AsyncSession] = None,
+    ) -> Optional[KnowledgeDirectoryModel]:
+        async with get_async_db_context(db) as db:
+            try:
+                await db.execute(
+                    update(KnowledgeDirectory)
+                    .filter_by(id=directory_id)
+                    .values(name=name, updated_at=int(time.time()))
+                )
+                await db.commit()
+                return await self.get_directory_by_id(directory_id, db=db)
+            except Exception as e:
+                log.exception(e)
+                return None
+
+    async def move_directory(
+        self,
+        directory_id: str,
+        new_parent_id: Optional[str],
+        db: Optional[AsyncSession] = None,
+    ) -> Optional[KnowledgeDirectoryModel]:
+        """Move a directory to a new parent, with cycle detection."""
+        async with get_async_db_context(db) as db:
+            try:
+                # Cycle detection: walk up from new_parent_id to ensure
+                # we don't encounter directory_id
+                if new_parent_id:
+                    current = new_parent_id
+                    seen = set()
+                    while current and current not in seen:
+                        if current == directory_id:
+                            return None  # Would create a cycle
+                        seen.add(current)
+                        result = await db.execute(
+                            select(KnowledgeDirectory.parent_id).filter_by(id=current)
+                        )
+                        row = result.first()
+                        current = row[0] if row else None
+
+                await db.execute(
+                    update(KnowledgeDirectory)
+                    .filter_by(id=directory_id)
+                    .values(parent_id=new_parent_id, updated_at=int(time.time()))
+                )
+                await db.commit()
+                return await self.get_directory_by_id(directory_id, db=db)
+            except Exception as e:
+                log.exception(e)
+                return None
+
+    async def update_directory(
+        self,
+        directory_id: str,
+        name: Optional[str] = None,
+        parent_id: Optional[str] = '__unset__',
+        db: Optional[AsyncSession] = None,
+    ) -> Optional[KnowledgeDirectoryModel]:
+        """Update directory name and/or parent. Pass parent_id=None to move to root."""
+        # Handle move if parent_id is being changed
+        if parent_id != '__unset__':
+            result = await self.move_directory(directory_id, parent_id, db=db)
+            if result is None:
+                return None  # Cycle detected or error
+
+        if name is not None:
+            return await self.rename_directory(directory_id, name, db=db)
+
+        return await self.get_directory_by_id(directory_id, db=db)
+
+    async def delete_directory(
+        self,
+        directory_id: str,
+        move_files_to_parent: bool = True,
+        db: Optional[AsyncSession] = None,
+    ) -> bool:
+        """
+        Delete a directory.
+        - If move_files_to_parent=True: files move to parent dir (or root)
+        - If move_files_to_parent=False: files are also deleted
+        """
+        async with get_async_db_context(db) as db:
+            try:
+                # Get the directory to find its parent
+                result = await db.execute(
+                    select(KnowledgeDirectory).filter_by(id=directory_id)
+                )
+                directory = result.scalars().first()
+                if not directory:
+                    return False
+
+                parent_id = directory.parent_id
+
+                if move_files_to_parent:
+                    # Move files in this directory to its parent (or root)
+                    await db.execute(
+                        update(KnowledgeFile)
+                        .filter_by(directory_id=directory_id)
+                        .values(directory_id=parent_id)
+                    )
+                    # Recursively move files from all subdirectories too
+                    await self._move_files_from_subtree(directory_id, parent_id, db=db)
+                else:
+                    # Delete files in this directory and all subdirectories
+                    await self._delete_files_in_subtree(directory_id, db=db)
+
+                # CASCADE on parent_id will handle deleting subdirectories
+                await db.execute(
+                    delete(KnowledgeDirectory).filter_by(id=directory_id)
+                )
+                await db.commit()
+                return True
+            except Exception as e:
+                log.exception(e)
+                return False
+
+    async def _move_files_from_subtree(
+        self,
+        directory_id: str,
+        target_directory_id: Optional[str],
+        db: AsyncSession,
+    ) -> None:
+        """Recursively move all files from a directory subtree to the target."""
+        result = await db.execute(
+            select(KnowledgeDirectory.id).filter_by(parent_id=directory_id)
+        )
+        child_ids = [row[0] for row in result.all()]
+
+        for child_id in child_ids:
+            await db.execute(
+                update(KnowledgeFile)
+                .filter_by(directory_id=child_id)
+                .values(directory_id=target_directory_id)
+            )
+            await self._move_files_from_subtree(child_id, target_directory_id, db=db)
+
+    async def _delete_files_in_subtree(
+        self,
+        directory_id: str,
+        db: AsyncSession,
+    ) -> None:
+        """Recursively delete all files from a directory subtree."""
+        await db.execute(
+            delete(KnowledgeFile).filter_by(directory_id=directory_id)
+        )
+        result = await db.execute(
+            select(KnowledgeDirectory.id).filter_by(parent_id=directory_id)
+        )
+        child_ids = [row[0] for row in result.all()]
+        for child_id in child_ids:
+            await self._delete_files_in_subtree(child_id, db=db)
+
+    async def move_file_to_directory(
+        self,
+        knowledge_id: str,
+        file_id: str,
+        directory_id: Optional[str] = None,
+        db: Optional[AsyncSession] = None,
+    ) -> bool:
+        """Move a file to a different directory within the same KB."""
+        async with get_async_db_context(db) as db:
+            try:
+                await db.execute(
+                    update(KnowledgeFile)
+                    .filter_by(knowledge_id=knowledge_id, file_id=file_id)
+                    .values(directory_id=directory_id, updated_at=int(time.time()))
+                )
+                await db.commit()
+                return True
+            except Exception as e:
+                log.exception(e)
+                return False
+
 
 Knowledges = KnowledgeTable()

backend/open_webui/routers/knowledge.py

@@ -15,6 +15,8 @@ from open_webui.models.access_grants import AccessGrants
 from open_webui.models.files import FileMetadataResponse, FileModel, Files
 from open_webui.models.groups import Groups
 from open_webui.models.knowledge import (
+    KnowledgeDirectoryForm,
+    KnowledgeDirectoryModel,
     KnowledgeFileListResponse,
     KnowledgeForm,
     KnowledgeResponse,
@@ -558,6 +560,7 @@ async def get_knowledge_files_by_id(
     view_option: str | None = None,
     order_by: str | None = None,
     direction: str | None = None,
+    directory_id: str | None = Query(None, description='Filter by directory ID. Pass empty string for root.'),
     page: int | None = 1,
     user=Depends(get_verified_user),
     db: AsyncSession = Depends(get_async_session),
@@ -599,6 +602,9 @@ async def get_knowledge_files_by_id(
         filter['order_by'] = order_by
     if direction:
         filter['direction'] = direction
+    # directory_id filtering: present in filter = scope to that directory (None = root)
+    if directory_id is not None:
+        filter['directory_id'] = directory_id if directory_id else None
 
     return await Knowledges.search_files_by_id(id, user.id, filter=filter, skip=skip, limit=limit, db=db)
 
@@ -610,6 +616,7 @@ async def get_knowledge_files_by_id(
 
 class KnowledgeFileIdForm(BaseModel):
     file_id: str
+    directory_id: Optional[str] = None
 
 
 @router.post('/{id}/file/add', response_model=KnowledgeFilesResponse | None)
@@ -673,7 +680,13 @@ async def add_file_to_knowledge_by_id(
         )
 
         # Add file to knowledge base
-        await Knowledges.add_file_to_knowledge_by_id(knowledge_id=id, file_id=form_data.file_id, user_id=user.id, db=db)
+        await Knowledges.add_file_to_knowledge_by_id(
+            knowledge_id=id,
+            file_id=form_data.file_id,
+            user_id=user.id,
+            directory_id=form_data.directory_id,
+            db=db,
+        )
     except Exception as e:
         log.debug(e)
         raise HTTPException(
@@ -1117,3 +1130,178 @@ async def export_knowledge_by_id(id: str, user=Depends(get_admin_user), db: Asyn
         media_type='application/zip',
         headers={'Content-Disposition': content_disposition},
     )
+
+
+############################
+# Directory endpoints
+############################
+
+
+class KnowledgeDirectoryCreateForm(BaseModel):
+    name: str
+    parent_id: Optional[str] = None
+
+
+class KnowledgeDirectoryUpdateForm(BaseModel):
+    name: Optional[str] = None
+    parent_id: Optional[str] = '__unset__'
+
+
+class KnowledgeFileMoveForm(BaseModel):
+    file_id: str
+    directory_id: Optional[str] = None
+
+
+async def _verify_knowledge_write_access(
+    id: str, user, db: AsyncSession
+):
+    """Verify the user has write access to the knowledge base. Returns the knowledge model."""
+    knowledge = await Knowledges.get_knowledge_by_id(id=id, db=db)
+    if not knowledge:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERROR_MESSAGES.NOT_FOUND,
+        )
+    if (
+        knowledge.user_id != user.id
+        and not await AccessGrants.has_access(
+            user_id=user.id,
+            resource_type='knowledge',
+            resource_id=knowledge.id,
+            permission='write',
+            db=db,
+        )
+        and user.role != 'admin'
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=ERROR_MESSAGES.ACCESS_PROHIBITED,
+        )
+    return knowledge
+
+
+@router.post('/{id}/dirs/create', response_model=KnowledgeDirectoryModel)
+async def create_knowledge_directory(
+    id: str,
+    form_data: KnowledgeDirectoryCreateForm,
+    user=Depends(get_verified_user),
+    db: AsyncSession = Depends(get_async_session),
+):
+    await _verify_knowledge_write_access(id, user, db)
+
+    directory = await Knowledges.create_directory(
+        knowledge_id=id,
+        name=form_data.name,
+        user_id=user.id,
+        parent_id=form_data.parent_id,
+        db=db,
+    )
+    if not directory:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Failed to create directory. A directory with this name may already exist at this level.',
+        )
+    return directory
+
+
+@router.post('/{id}/dirs/{dir_id}/update', response_model=KnowledgeDirectoryModel)
+async def update_knowledge_directory(
+    id: str,
+    dir_id: str,
+    form_data: KnowledgeDirectoryUpdateForm,
+    user=Depends(get_verified_user),
+    db: AsyncSession = Depends(get_async_session),
+):
+    await _verify_knowledge_write_access(id, user, db)
+
+    # Verify directory belongs to this knowledge base
+    directory = await Knowledges.get_directory_by_id(dir_id, db=db)
+    if not directory or directory.knowledge_id != id:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERROR_MESSAGES.NOT_FOUND,
+        )
+
+    result = await Knowledges.update_directory(
+        directory_id=dir_id,
+        name=form_data.name,
+        parent_id=form_data.parent_id,
+        db=db,
+    )
+    if not result:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Failed to update directory. This may be caused by a naming conflict or circular move.',
+        )
+    return result
+
+
+@router.delete('/{id}/dirs/{dir_id}/delete')
+async def delete_knowledge_directory(
+    id: str,
+    dir_id: str,
+    move_files: bool = Query(True, description='If true, move contained files to parent. If false, delete them.'),
+    user=Depends(get_verified_user),
+    db: AsyncSession = Depends(get_async_session),
+):
+    await _verify_knowledge_write_access(id, user, db)
+
+    # Verify directory belongs to this knowledge base
+    directory = await Knowledges.get_directory_by_id(dir_id, db=db)
+    if not directory or directory.knowledge_id != id:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERROR_MESSAGES.NOT_FOUND,
+        )
+
+    success = await Knowledges.delete_directory(
+        directory_id=dir_id,
+        move_files_to_parent=move_files,
+        db=db,
+    )
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to delete directory.',
+        )
+    return {'status': True}
+
+
+@router.post('/{id}/file/move')
+async def move_file_in_knowledge(
+    id: str,
+    form_data: KnowledgeFileMoveForm,
+    user=Depends(get_verified_user),
+    db: AsyncSession = Depends(get_async_session),
+):
+    await _verify_knowledge_write_access(id, user, db)
+
+    # Verify file belongs to this knowledge base
+    if not await Knowledges.has_file(knowledge_id=id, file_id=form_data.file_id, db=db):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERROR_MESSAGES.NOT_FOUND,
+        )
+
+    # If target directory is set, verify it belongs to this knowledge base
+    if form_data.directory_id:
+        directory = await Knowledges.get_directory_by_id(form_data.directory_id, db=db)
+        if not directory or directory.knowledge_id != id:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Target directory not found.',
+            )
+
+    success = await Knowledges.move_file_to_directory(
+        knowledge_id=id,
+        file_id=form_data.file_id,
+        directory_id=form_data.directory_id,
+        db=db,
+    )
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to move file.',
+        )
+    return {'status': True}
+