MindsDB 25.2.4.0__py3-none-any.whl → 25.3.2.0__py3-none-any.whl

mindsdb/integrations/utilities/sql_utils.py

@@ -7,6 +7,7 @@ from mindsdb_sql_parser import ast
 from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.integrations.utilities.query_traversal import query_traversal
+from mindsdb.utilities.config import config
 
 
 class FilterOperator(Enum):
@@ -74,7 +75,7 @@ def make_sql_session():
     from mindsdb.api.executor.controllers.session_controller import SessionController
 
     sql_session = SessionController()
-    sql_session.database = 'mindsdb'
+    sql_session.database = config.get('default_project')
     return sql_session
 
 

mindsdb/interfaces/agents/agents_controller.py

@@ -13,12 +13,16 @@ from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.model.model_controller import ModelController
 from mindsdb.interfaces.skills.skills_controller import SkillsController
+from mindsdb.utilities.config import config
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
 
 from .constants import ASSISTANT_COLUMN, SUPPORTED_PROVIDERS, PROVIDER_TO_MODELS
 from .langchain_agent import get_llm_provider
 
 
+default_project = config.get('default_project')
+
+
 class AgentsController:
     '''Handles CRUD operations at the database level for Agents'''
 
@@ -70,7 +74,7 @@ class AgentsController:
 
         return model, provider
 
-    def get_agent(self, agent_name: str, project_name: str = 'mindsdb') -> Optional[db.Agents]:
+    def get_agent(self, agent_name: str, project_name: str = default_project) -> Optional[db.Agents]:
         '''
         Gets an agent by name.
 
@@ -91,7 +95,7 @@ class AgentsController:
         ).first()
         return agent
 
-    def get_agent_by_id(self, id: int, project_name: str = 'mindsdb') -> db.Agents:
+    def get_agent_by_id(self, id: int, project_name: str = default_project) -> db.Agents:
         '''
         Gets an agent by id.
 
@@ -162,7 +166,7 @@ class AgentsController:
             ValueError: Agent with given name already exists, or skill/model with given name does not exist.
         '''
         if project_name is None:
-            project_name = 'mindsdb'
+            project_name = default_project
         project = self.project_controller.get(name=project_name)
 
         agent = self.get_agent(name, project_name)
@@ -208,7 +212,7 @@ class AgentsController:
     def update_agent(
             self,
             agent_name: str,
-            project_name: str = 'mindsdb',
+            project_name: str = default_project,
             name: str = None,
             model_name: str = None,
             skills_to_add: List[Union[str, dict]] = None,
@@ -347,7 +351,7 @@ class AgentsController:
 
         return existing_agent
 
-    def delete_agent(self, agent_name: str, project_name: str = 'mindsdb'):
+    def delete_agent(self, agent_name: str, project_name: str = default_project):
         '''
         Deletes an agent by name.
 
@@ -371,7 +375,7 @@ class AgentsController:
             self,
             agent: db.Agents,
             messages: List[Dict[str, str]],
-            project_name: str = 'mindsdb',
+            project_name: str = default_project,
             tools: List[BaseTool] = None,
             stream: bool = False) -> Union[Iterator[object], pd.DataFrame]:
         """
@@ -412,7 +416,7 @@ class AgentsController:
             self,
             agent: db.Agents,
             messages: List[Dict[str, str]],
-            project_name: str = 'mindsdb',
+            project_name: str = default_project,
             tools: List[BaseTool] = None) -> Iterator[object]:
         '''
         Queries an agent to get a stream of completion chunks.

mindsdb/interfaces/agents/mindsdb_chat_model.py

@@ -31,8 +31,10 @@ from langchain_core.outputs import (
 from pydantic import model_validator
 
 from mindsdb.interfaces.agents.constants import USER_COLUMN
+from mindsdb.utilities.config import config
 
 logger = logging.getLogger(__name__)
+default_project = config.get('default_project')
 
 
 def _convert_message_to_dict(message: BaseMessage) -> dict:
@@ -63,7 +65,7 @@ class ChatMindsdb(BaseChatModel):
     """A chat model that uses the Mindsdb"""
 
     model_name: str
-    project_name: Optional[str] = 'mindsdb'
+    project_name: Optional[str] = default_project
     model_info: Optional[dict] = None
     project_datanode: Optional[Any] = None
 
@@ -139,7 +141,7 @@ class ChatMindsdb(BaseChatModel):
         from mindsdb.api.executor.controllers import SessionController
 
         session = SessionController()
-        session.database = 'mindsdb'
+        session.database = default_project
 
         values['model_info'] = session.model_controller.get_model(model_name, project_name=project_name)
 

mindsdb/interfaces/chatbot/chatbot_controller.py

@@ -9,7 +9,10 @@ from mindsdb.interfaces.model.functions import get_project_records
 from mindsdb.utilities.context import context as ctx
 
 from mindsdb.api.executor.controllers.session_controller import SessionController
-from mindsdb.utilities.config import Config
+from mindsdb.utilities.config import config
+
+
+default_project = config.get('default_project')
 
 
 class ChatBotController:
@@ -25,7 +28,7 @@ class ChatBotController:
         self.project_controller = project_controller
         self.agents_controller = agents_controller
 
-    def get_chatbot(self, chatbot_name: str, project_name: str = 'mindsdb') -> dict:
+    def get_chatbot(self, chatbot_name: str, project_name: str = default_project) -> dict:
         '''
         Gets a chatbot by name.
 
@@ -118,7 +121,7 @@ class ChatBotController:
 
         return bot_obj
 
-    def get_chatbots(self, project_name: str = 'mindsdb') -> List[dict]:
+    def get_chatbots(self, project_name: str = default_project) -> List[dict]:
         '''
         Gets all chatbots in a project.
 
@@ -199,14 +202,12 @@ class ChatBotController:
             bot (db.ChatBots): The created chatbot
         '''
 
-        config = Config()
-
         is_cloud = config.get('cloud', False)
         if is_cloud and ctx.user_class == 0:
             raise Exception("You can't create chatbot")
 
         if project_name is None:
-            project_name = 'mindsdb'
+            project_name = default_project
         project = self.project_controller.get(name=project_name)
 
         bot = self.get_chatbot(name, project_name)
@@ -260,7 +261,7 @@ class ChatBotController:
     def update_chatbot(
             self,
             chatbot_name: str,
-            project_name: str = 'mindsdb',
+            project_name: str = default_project,
             name: str = None,
             model_name: str = None,
             agent_name: str = None,
@@ -338,7 +339,7 @@ class ChatBotController:
 
         return existing_chatbot_rec
 
-    def delete_chatbot(self, chatbot_name: str, project_name: str = 'mindsdb'):
+    def delete_chatbot(self, chatbot_name: str, project_name: str = default_project):
         '''
         Deletes a chatbot by name.
 

mindsdb/interfaces/database/database.py

@@ -3,6 +3,7 @@ from collections import OrderedDict
 
 from mindsdb.interfaces.database.projects import ProjectController
 import mindsdb.utilities.profiler as profiler
+from mindsdb.utilities.config import config
 from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.interfaces.database.log import LogDBController
 
@@ -58,7 +59,7 @@ class DatabaseController:
                 'id': x.id,
                 'engine': None,
                 'visible': True,
-                'deletable': x.name.lower() != 'mindsdb'
+                'deletable': x.name.lower() != config.get('default_project')
             })
         for key, value in integrations.items():
             db_type = value.get('type', 'data')

mindsdb/interfaces/database/projects.py

@@ -4,6 +4,7 @@ from typing import List, Optional
 from collections import OrderedDict
 
 import sqlalchemy as sa
+from sqlalchemy.orm.attributes import flag_modified
 import numpy as np
 
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -30,6 +31,7 @@ class Project:
         p.name = db_record.name
         p.company_id = ctx.company_id
         p.id = db_record.id
+        p.metadata = db_record.metadata_
         return p
 
     def create(self, name: str):
@@ -405,9 +407,9 @@ class ProjectController:
 
         return [Project.from_record(x) for x in records]
 
-    def get(self, id: Optional[int] = None, name: Optional[str] = None, deleted: bool = False) -> Project:
+    def get(self, id: Optional[int] = None, name: Optional[str] = None, deleted: bool = False, is_default: bool = False) -> Project:
         if id is not None and name is not None:
-            raise ValueError("Both 'id' and 'name' is None")
+            raise ValueError("Both 'id' and 'name' can't be provided at the same time")
 
         company_id = ctx.company_id if ctx.company_id is not None else 0
         q = db.Project.query.filter_by(company_id=company_id)
@@ -424,6 +426,9 @@ class ProjectController:
         else:
             q = q.filter_by(deleted_at=sa.null())
 
+        if is_default:
+            q = q.filter(db.Project.metadata_['is_default'].as_boolean() == is_default)
+
         record = q.first()
 
         if record is None:
@@ -434,3 +439,24 @@ class ProjectController:
         project = Project()
         project.create(name=name)
         return project
+
+    def update(self, id: Optional[int] = None, name: Optional[str] = None, new_name: str = None, new_metadata: dict = None) -> Project:
+        if id is not None and name is not None:
+            raise ValueError("Both 'id' and 'name' can't be provided at the same time")
+
+        if id is not None:
+            project = self.get(id=id)
+        else:
+            project = self.get(name=name)
+
+        if new_name is not None:
+            project.name = new_name
+            project.record.name = new_name
+
+        if new_metadata is not None:
+            project.metadata = new_metadata
+            project.record.metadata = new_metadata
+            flag_modified(project.record, 'metadata_')
+
+        db.session.commit()
+        return project

mindsdb/interfaces/jobs/jobs_controller.py

@@ -9,6 +9,7 @@ from mindsdb_sql_parser import parse_sql, ParsingException
 from mindsdb_sql_parser.ast.mindsdb import CreateJob
 from mindsdb_sql_parser.ast import Select, Star, Identifier, BinaryOperation, Constant
 
+from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.exception import EntityNotExistsError, EntityExistsError
 from mindsdb.interfaces.storage import db
@@ -20,6 +21,8 @@ from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
+default_project = config.get('default_project')
+
 
 def split_sql(sql):
     # split sql by ';' ignoring delimiter in quotes
@@ -199,7 +202,7 @@ class JobsController:
         """
 
         if project_name is None:
-            project_name = 'mindsdb'
+            project_name = default_project
 
         start_at = None
         if query.start_str is not None:

mindsdb/interfaces/model/model_controller.py

@@ -19,6 +19,7 @@ from mindsdb.interfaces.model.functions import (
 )
 from mindsdb.interfaces.storage.json import get_json_storage
 from mindsdb.interfaces.storage.model_fs import ModelStorage
+from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.functions import resolve_model_identifier
 import mindsdb.utilities.profiler as profiler
@@ -29,6 +30,8 @@ logger = log.getLogger(__name__)
 
 IS_PY36 = sys.version_info[1] <= 6
 
+default_project = config.get('default_project')
+
 
 def delete_model_storage(model_id, ctx_dump):
     try:
@@ -149,7 +152,7 @@ class ModelController():
             models.append(model_data)
         return models
 
-    def delete_model(self, model_name: str, project_name: str = 'mindsdb', version=None):
+    def delete_model(self, model_name: str, project_name: str = default_project, version=None):
         from mindsdb.interfaces.database.database import DatabaseController
 
         project_record = get_project_record(func.lower(project_name))
@@ -344,7 +347,7 @@ class ModelController():
     def prepare_finetune_statement(self, statement, database_controller):
         project_name, model_name, model_version = resolve_model_identifier(statement.name)
         if project_name is None:
-            project_name = 'mindsdb'
+            project_name = default_project
         data_integration_ref, fetch_data_query = self._get_data_integration_ref(statement, database_controller)
 
         set_active = True

mindsdb/interfaces/skills/retrieval_tool.py

@@ -1,33 +1,24 @@
+import traceback
+
 from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
 from mindsdb.integrations.utilities.rag.config_loader import load_rag_config
+from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
 
 from mindsdb.interfaces.agents.constants import DEFAULT_EMBEDDINGS_MODEL_CLASS
 from mindsdb.interfaces.skills.skill_tool import skill_tool
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.storage.db import KnowledgeBase
 from mindsdb.utilities import log
+from langchain_core.documents import Document
 from langchain_core.tools import Tool
+from mindsdb.integrations.libs.response import RESPONSE_TYPE
 from mindsdb.integrations.handlers.langchain_embedding_handler.langchain_embedding_handler import construct_model_from_args
 
 logger = log.getLogger(__name__)
 
 
-def build_retrieval_tool(tool: dict, pred_args: dict, skill: db.Skills):
-    """
-    Builds a retrieval tool i.e RAG
-
-    Args:
-        tool: Tool configuration dictionary
-        pred_args: Predictor arguments dictionary
-        skill: Skills database object
-
-    Returns:
-        Tool: Configured retrieval tool
-
-    Raises:
-        ValueError: If knowledge base is not found or configuration is invalid
-    """
-    # build RAG config
+def _load_rag_config(tool: dict, pred_args: dict, skill: db.Skills) -> RAGPipelineModel:
     tools_config = tool['config']
     tools_config.update(pred_args)
 
@@ -71,34 +62,132 @@ def build_retrieval_tool(tool: dict, pred_args: dict, skill: db.Skills):
         logger.debug("Using default embedding model as no knowledge base provided")
 
     # Load and validate config
-    try:
-        rag_config = load_rag_config(tools_config, kb_params, embeddings_model)
-        # build retriever
-        rag_pipeline = RAG(rag_config)
-        logger.debug(f"RAG pipeline created with config: {rag_config}")
-
-        def rag_wrapper(query: str) -> str:
-            try:
-                result = rag_pipeline(query)
-                logger.debug(f"RAG pipeline result: {result}")
-                return result['answer']
-            except Exception as e:
-                logger.error(f"Error in RAG pipeline: {str(e)}")
-                return f"Error in retrieval: {str(e)}"
-
-        # Create RAG tool
-        return Tool(
-            func=rag_wrapper,
-            name=tool['name'],
-            description=tool['description'],
-            response_format='content',
-            # Return directly by default since we already use an LLM against retrieved context to generate a response.
-            return_direct=tools_config.get('return_direct', True)
+    return load_rag_config(tools_config, kb_params, embeddings_model)
+
+
+def _build_rag_pipeline_tool(tool: dict, pred_args: dict, skill: db.Skills):
+    rag_config = _load_rag_config(tool, pred_args, skill)
+    # build retriever
+    rag_pipeline = RAG(rag_config)
+    logger.debug(f"RAG pipeline created with config: {rag_config}")
+
+    def rag_wrapper(query: str) -> str:
+        try:
+            result = rag_pipeline(query)
+            logger.debug(f"RAG pipeline result: {result}")
+            return result['answer']
+        except Exception as e:
+            logger.error(f"Error in RAG pipeline: {str(e)}")
+            logger.error(traceback.format_exc())
+            return f"Error in retrieval: {str(e)}"
+
+    # Create RAG tool
+    tools_config = tool['config']
+    tools_config.update(pred_args)
+    return Tool(
+        func=rag_wrapper,
+        name=tool['name'],
+        description=tool['description'],
+        response_format='content',
+        # Return directly by default since we already use an LLM against retrieved context to generate a response.
+        return_direct=tools_config.get('return_direct', True)
+    )
+
+
+def _build_name_lookup_tool(tool: dict, pred_args: dict, skill: db.Skills):
+    if 'source' not in tool:
+        raise ValueError("Knowledge base for tool not found")
+    kb_name = tool['source']
+    executor = skill_tool.get_command_executor()
+    kb = _get_knowledge_base(kb_name, skill.project_id, executor)
+    if not kb:
+        raise ValueError(f"Knowledge base not found: {kb_name}")
+    kb_table = executor.session.kb_controller.get_table(kb.name, kb.project_id)
+    vector_db_handler = kb_table.get_vector_db()
+
+    rag_config = _load_rag_config(tool, pred_args, skill)
+    metadata_config = rag_config.metadata_config
+
+    def _get_document_by_name(name: str):
+        if metadata_config.name_column_index is not None:
+            tsquery_str = ' & '.join(name.split(' '))
+            documents_response = vector_db_handler.native_query(
+                f'SELECT * FROM {metadata_config.table} WHERE {metadata_config.name_column_index} @@ to_tsquery(\'{tsquery_str}\') LIMIT 1;'
+            )
+        else:
+            documents_response = vector_db_handler.native_query(
+                f'SELECT * FROM {metadata_config.table} WHERE "{metadata_config.name_column}" ILIKE \'%{name}%\' LIMIT 1;'
+            )
+        if documents_response.resp_type == RESPONSE_TYPE.ERROR:
+            raise RuntimeError(f'There was an error looking up documents: {documents_response.error_message}')
+        if documents_response.data_frame.empty:
+            return None
+        document_row = documents_response.data_frame.head(1)
+        # Restore document from chunks, keeping in mind max context.
+        id_filter_condition = FilterCondition(
+            f"{metadata_config.embeddings_metadata_column}->>'{metadata_config.doc_id_key}'",
+            FilterOperator.EQUAL,
+            str(document_row.get(metadata_config.id_column).item())
+        )
+        document_chunks_df = vector_db_handler.select(
+            metadata_config.embeddings_table,
+            conditions=[id_filter_condition]
         )
+        if document_chunks_df.empty:
+            return None
+        sort_col = 'chunk_id' if 'chunk_id' in document_chunks_df.columns else 'id'
+        document_chunks_df.sort_values(by=sort_col)
+        content = ''
+        for _, chunk in document_chunks_df.iterrows():
+            if len(content) > metadata_config.max_document_context:
+                break
+            content += chunk.get(metadata_config.content_column, '')
+
+        return Document(
+            page_content=content,
+            metadata=document_row.to_dict(orient='records')[0]
+        )
+
+    def _lookup_document_by_name(name: str):
+        found_document = _get_document_by_name(name)
+        if found_document is None:
+            return f'I could not find any document with name {name}. Please make sure the document name matches exactly.'
+        return f"I found document {found_document.metadata.get(metadata_config.id_column)} with name {found_document.metadata.get(metadata_config.name_column)}. Here is the full document to use as context:\n\n{found_document.page_content}"
+
+    return Tool(
+        func=_lookup_document_by_name,
+        name=tool.get('name', '') + '_name_lookup',
+        description='You must use this tool ONLY when the user is asking about a specific document by name or title. The input should be the exact name of the document the user is looking for.',
+        return_direct=False
+    )
 
+
+def build_retrieval_tools(tool: dict, pred_args: dict, skill: db.Skills):
+    """
+    Builds a list of tools for retrieval i.e RAG
+
+    Args:
+        tool: Tool configuration dictionary
+        pred_args: Predictor arguments dictionary
+        skill: Skills database object
+
+    Returns:
+        Tool: Configured list of retrieval tools
+
+    Raises:
+        ValueError: If knowledge base is not found or configuration is invalid
+    """
+    # Catch configuration errors before creating tools.
+    try:
+        rag_config = _load_rag_config(tool, pred_args, skill)
     except Exception as e:
         logger.error(f"Error building RAG pipeline: {str(e)}")
         raise ValueError(f"Failed to build RAG pipeline: {str(e)}")
+    tools = [_build_rag_pipeline_tool(tool, pred_args, skill)]
+    if rag_config.metadata_config is None:
+        return tools
+    tools.append(_build_name_lookup_tool(tool, pred_args, skill))
+    return tools
 
 
 def _get_knowledge_base(knowledge_base_name: str, project_id, executor) -> KnowledgeBase:

mindsdb/interfaces/skills/skill_tool.py

@@ -10,6 +10,7 @@ from mindsdb_sql_parser.ast import Select, BinaryOperation, Identifier, Constant
 
 from mindsdb.utilities import log
 from mindsdb.utilities.cache import get_cache
+from mindsdb.utilities.config import config
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.skills.sql_agent import SQLAgent
 from mindsdb.integrations.libs.vectordatabase_handler import TableField
@@ -106,7 +107,7 @@ class SkillToolController:
             from mindsdb.api.executor.controllers import SessionController  # Top-level import produces circular import in some cases TODO: figure out a fix without losing runtime improvements (context: see #9304)  # noqa
 
             sql_session = SessionController()
-            sql_session.database = 'mindsdb'
+            sql_session.database = config.get('default_project')
 
             self.command_executor = ExecuteCommands(sql_session)
         return self.command_executor
@@ -222,8 +223,8 @@ class SkillToolController:
         pred_args = {}
         pred_args['llm'] = llm
 
-        from .retrieval_tool import build_retrieval_tool
-        return build_retrieval_tool(tool, pred_args, skill)
+        from .retrieval_tool import build_retrieval_tools
+        return build_retrieval_tools(tool, pred_args, skill)
 
     def _get_rag_query_function(self, skill: db.Skills):
         session_controller = self.get_command_executor().session
@@ -295,10 +296,9 @@ class SkillToolController:
                     for skill in skills
                 ]
             elif skill_type == SkillType.RETRIEVAL:
-                tools[skill_type] = [
-                    self._make_retrieval_tools(skill, llm, embedding_model)
-                    for skill in skills
-                ]
+                tools[skill_type] = []
+                for skill in skills:
+                    tools[skill_type] += self._make_retrieval_tools(skill, llm, embedding_model)
         return tools
 
 

mindsdb/interfaces/skills/skills_controller.py

@@ -6,6 +6,10 @@ from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.database.projects import ProjectController
+from mindsdb.utilities.config import config
+
+
+default_project = config.get('default_project')
 
 
 class SkillsController:
@@ -16,7 +20,7 @@ class SkillsController:
             project_controller = ProjectController()
         self.project_controller = project_controller
 
-    def get_skill(self, skill_name: str, project_name: str = 'mindsdb') -> Optional[db.Skills]:
+    def get_skill(self, skill_name: str, project_name: str = default_project) -> Optional[db.Skills]:
         '''
         Gets a skill by name. Skills are expected to have unique names.
 
@@ -90,7 +94,7 @@ class SkillsController:
             ValueError: If `project_name` does not exist or skill already exists
         '''
         if project_name is None:
-            project_name = 'mindsdb'
+            project_name = default_project
         project = self.project_controller.get(name=project_name)
 
         skill = self.get_skill(name, project_name)
@@ -113,7 +117,7 @@ class SkillsController:
             self,
             skill_name: str,
             new_name: str = None,
-            project_name: str = 'mindsdb',
+            project_name: str = default_project,
             type: str = None,
             params: Dict[str, str] = None):
         '''
@@ -158,7 +162,7 @@ class SkillsController:
 
         return existing_skill
 
-    def delete_skill(self, skill_name: str, project_name: str = 'mindsdb'):
+    def delete_skill(self, skill_name: str, project_name: str = default_project):
         '''
         Deletes a skill by name.
 

mindsdb/interfaces/storage/db.py

@@ -10,6 +10,7 @@ from sqlalchemy import (
     DateTime,
     Index,
     Integer,
+    LargeBinary,
     Numeric,
     String,
     UniqueConstraint,
@@ -213,6 +214,7 @@ class Project(Base):
     deleted_at = Column(DateTime)
     name = Column(String, nullable=False)
     company_id = Column(Integer, default=0)
+    metadata_: dict = Column("metadata", JSON, nullable=True)
     __table_args__ = (
         UniqueConstraint("name", "company_id", name="unique_project_name_company_id"),
     )
@@ -276,8 +278,20 @@ class JsonStorage(Base):
     resource_id = Column(Integer)
     name = Column(String)
     content = Column(JSON)
+    encrypted_content = Column(LargeBinary, nullable=True)
     company_id = Column(Integer)
 
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "resource_group": self.resource_group,
+            "resource_id": self.resource_id,
+            "name": self.name,
+            "content": self.content,
+            "encrypted_content": self.encrypted_content,
+            "company_id": self.company_id,
+        }
+
 
 class Jobs(Base):
     __tablename__ = "jobs"