MindsDB 25.4.5.0__py3-none-any.whl → 25.5.4.0__py3-none-any.whl

mindsdb/interfaces/agents/agents_controller.py

@@ -19,9 +19,10 @@ 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')
 
+DEFAULT_TEXT2SQL_DATABASE = 'mindsdb'
+
 
 class AgentsController:
     '''Handles CRUD operations at the database level for Agents'''
@@ -158,6 +159,13 @@ class AgentsController:
                  with one of keys is "name", and other is additional parameters for relationship agent<>skill
             provider (str): The provider of the model
             params (Dict[str, str]): Parameters to use when running the agent
+                database: The database to use for text2sql skills (default is 'mindsdb')
+                knowledge_base_database: The database to use for knowledge base queries (default is 'mindsdb')
+                include_tables: List of tables to include for text2sql skills
+                ignore_tables: List of tables to ignore for text2sql skills
+                include_knowledge_bases: List of knowledge bases to include for text2sql skills
+                ignore_knowledge_bases: List of knowledge bases to ignore for text2sql skills
+                <provider>_api_key: API key for the provider (e.g., openai_api_key)
 
         Returns:
             agent (db.Agents): The created agent
@@ -176,6 +184,128 @@ class AgentsController:
 
         _, provider = self.check_model_provider(model_name, provider)
 
+        # Extract API key if provided in the format <provider>_api_key
+        provider_api_key_param = f"{provider.lower()}_api_key"
+        if provider_api_key_param in params:
+            # Keep the API key in params for the agent to use
+            # It will be picked up by get_api_key() in handler_utils.py
+            pass
+
+        # Extract table and knowledge base parameters from params
+        database = params.pop('database', None)
+        knowledge_base_database = params.pop('knowledge_base_database', DEFAULT_TEXT2SQL_DATABASE)
+        include_tables = params.pop('include_tables', None)
+        ignore_tables = params.pop('ignore_tables', None)
+        include_knowledge_bases = params.pop('include_knowledge_bases', None)
+        ignore_knowledge_bases = params.pop('ignore_knowledge_bases', None)
+
+        # Save the extracted parameters back to params for API responses only if they were explicitly provided
+        # or if they're needed for skills
+        need_params = include_tables or ignore_tables or include_knowledge_bases or ignore_knowledge_bases
+
+        if 'database' in params or need_params:
+            params['database'] = database
+
+        if 'knowledge_base_database' in params or include_knowledge_bases or ignore_knowledge_bases:
+            params['knowledge_base_database'] = knowledge_base_database
+
+        if include_tables is not None:
+            params['include_tables'] = include_tables
+        if ignore_tables is not None:
+            params['ignore_tables'] = ignore_tables
+        if include_knowledge_bases is not None:
+            params['include_knowledge_bases'] = include_knowledge_bases
+        if ignore_knowledge_bases is not None:
+            params['ignore_knowledge_bases'] = ignore_knowledge_bases
+
+        # Convert string parameters to lists if needed
+        if isinstance(include_tables, str):
+            include_tables = [t.strip() for t in include_tables.split(',')]
+        if isinstance(ignore_tables, str):
+            ignore_tables = [t.strip() for t in ignore_tables.split(',')]
+        if isinstance(include_knowledge_bases, str):
+            include_knowledge_bases = [kb.strip() for kb in include_knowledge_bases.split(',')]
+        if isinstance(ignore_knowledge_bases, str):
+            ignore_knowledge_bases = [kb.strip() for kb in ignore_knowledge_bases.split(',')]
+
+        # Auto-create SQL skill if no skills are provided but include_tables or include_knowledge_bases params are provided
+        if not skills and (include_tables or include_knowledge_bases):
+            # Determine database to use (default to 'mindsdb')
+            db_name = database
+            kb_db_name = knowledge_base_database
+
+            # If database is not explicitly provided but tables are, try to extract the database name from the first table
+            if not database and include_tables and len(include_tables) > 0:
+                parts = include_tables[0].split('.')
+                if len(parts) >= 2:
+                    db_name = parts[0]
+            elif not database and ignore_tables and len(ignore_tables) > 0:
+                parts = ignore_tables[0].split('.')
+                if len(parts) >= 2:
+                    db_name = parts[0]
+
+            # Create a default SQL skill
+            skill_name = f"{name}_sql_skill"
+            skill_params = {
+                'type': 'sql',
+                'database': db_name,
+                'description': f'Auto-generated SQL skill for agent {name}'
+            }
+
+            # Add knowledge base database if provided
+            if knowledge_base_database:
+                skill_params['knowledge_base_database'] = knowledge_base_database
+
+            # Add knowledge base parameters if provided
+            if include_knowledge_bases:
+                skill_params['include_knowledge_bases'] = include_knowledge_bases
+            if ignore_knowledge_bases:
+                skill_params['ignore_knowledge_bases'] = ignore_knowledge_bases
+
+            try:
+                # Check if skill already exists
+                existing_skill = self.skills_controller.get_skill(skill_name, project_name)
+                if existing_skill is None:
+                    # Create the skill
+                    skill_type = skill_params.pop('type')
+                    self.skills_controller.add_skill(
+                        name=skill_name,
+                        project_name=project_name,
+                        type=skill_type,
+                        params=skill_params
+                    )
+                else:
+                    # Update the skill if parameters have changed
+                    params_changed = False
+
+                    # Check if database has changed
+                    if existing_skill.params.get('database') != db_name:
+                        existing_skill.params['database'] = db_name
+                        params_changed = True
+
+                    # Check if knowledge base database has changed
+                    if knowledge_base_database and existing_skill.params.get('knowledge_base_database') != kb_db_name:
+                        existing_skill.params['knowledge_base_database'] = kb_db_name
+                        params_changed = True
+
+                    # Check if knowledge base parameters have changed
+                    if include_knowledge_bases and existing_skill.params.get('include_knowledge_bases') != include_knowledge_bases:
+                        existing_skill.params['include_knowledge_bases'] = include_knowledge_bases
+                        params_changed = True
+
+                    if ignore_knowledge_bases and existing_skill.params.get('ignore_knowledge_bases') != ignore_knowledge_bases:
+                        existing_skill.params['ignore_knowledge_bases'] = ignore_knowledge_bases
+                        params_changed = True
+
+                    # Update the skill if needed
+                    if params_changed:
+                        flag_modified(existing_skill, 'params')
+                        db.session.commit()
+
+                skills = [skill_name]
+            except Exception as e:
+                raise ValueError(f"Failed to auto-create or update SQL skill: {str(e)}")
+
         agent = db.Agents(
             name=name,
             project_id=project.id,
@@ -193,10 +323,43 @@ class AgentsController:
             else:
                 parameters = skill.copy()
                 skill_name = parameters.pop('name')
+
             existing_skill = self.skills_controller.get_skill(skill_name, project_name)
             if existing_skill is None:
                 db.session.rollback()
                 raise ValueError(f'Skill with name does not exist: {skill_name}')
+
+            # Add table restrictions if this is a text2sql skill
+            if existing_skill.type == 'sql' and (include_tables or ignore_tables):
+                parameters['tables'] = include_tables or ignore_tables
+
+            # Add knowledge base restrictions if this is a text2sql skill
+            if existing_skill.type == 'sql':
+                # Pass database parameter if provided
+                if database and 'database' not in parameters:
+                    parameters['database'] = database
+
+                # Pass knowledge base database parameter if provided
+                if knowledge_base_database and 'knowledge_base_database' not in parameters:
+                    parameters['knowledge_base_database'] = knowledge_base_database
+
+                # Add knowledge base parameters to both the skill and the association parameters
+                if include_knowledge_bases:
+                    parameters['include_knowledge_bases'] = include_knowledge_bases
+                    if 'include_knowledge_bases' not in existing_skill.params:
+                        existing_skill.params['include_knowledge_bases'] = include_knowledge_bases
+                        flag_modified(existing_skill, 'params')
+                elif ignore_knowledge_bases:
+                    parameters['ignore_knowledge_bases'] = ignore_knowledge_bases
+                    if 'ignore_knowledge_bases' not in existing_skill.params:
+                        existing_skill.params['ignore_knowledge_bases'] = ignore_knowledge_bases
+                        flag_modified(existing_skill, 'params')
+
+                # Ensure knowledge_base_database is set in the skill's params
+                if knowledge_base_database and 'knowledge_base_database' not in existing_skill.params:
+                    existing_skill.params['knowledge_base_database'] = knowledge_base_database
+                    flag_modified(existing_skill, 'params')
+
             association = db.AgentSkillsAssociation(
                 parameters=parameters,
                 agent=agent,

mindsdb/interfaces/agents/constants.py

@@ -4,8 +4,20 @@ from langchain.agents import AgentType
 from langchain_openai import OpenAIEmbeddings
 
 from types import MappingProxyType
-from mindsdb.integrations.handlers.openai_handler.constants import (
-    CHAT_MODELS as OPEN_AI_CHAT_MODELS,
+
+# the same as
+# from mindsdb.integrations.handlers.openai_handler.constants import CHAT_MODELS
+OPEN_AI_CHAT_MODELS = (
+    'gpt-3.5-turbo',
+    'gpt-3.5-turbo-16k',
+    'gpt-3.5-turbo-instruct',
+    'gpt-4',
+    'gpt-4-32k',
+    'gpt-4-1106-preview',
+    'gpt-4-0125-preview',
+    'gpt-4o',
+    'o3-mini',
+    'o1-mini'
 )
 
 SUPPORTED_PROVIDERS = {
@@ -190,3 +202,18 @@ DEFAULT_EMBEDDINGS_MODEL_PROVIDER = "openai"
 DEFAULT_EMBEDDINGS_MODEL_CLASS = OpenAIEmbeddings
 DEFAULT_TIKTOKEN_MODEL_NAME = os.getenv('DEFAULT_TIKTOKEN_MODEL_NAME', 'gpt-4')
 AGENT_CHUNK_POLLING_INTERVAL_SECONDS = os.getenv('AGENT_CHUNK_POLLING_INTERVAL_SECONDS', 1.0)
+DEFAULT_TEXT2SQL_DATABASE = "mindsdb"
+DEFAULT_AGENT_SYSTEM_PROMPT = """
+You are an AI assistant powered by MindsDB. When answering questions, follow these guidelines:
+
+1. For factual questions about specific topics, use the knowledge base tools in this sequence:
+   - First use kb_list_tool to see available knowledge bases
+   - Then use kb_info_tool to understand the structure of relevant knowledge bases
+   - Finally use kb_query_tool to query the knowledge base for specific information
+
+2. For questions about database tables and their contents:
+   - Use the sql_tool to query the tables directly
+   - You can join tables if needed to get comprehensive information
+
+For factual questions, ALWAYS use the available tools to look up information rather than relying on your internal knowledge.
+"""

mindsdb/interfaces/agents/langchain_agent.py

@@ -24,9 +24,6 @@ from langchain_core.messages.base import BaseMessage
 from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import Tool
 
-from mindsdb.integrations.handlers.openai_handler.constants import (
-    CHAT_MODELS as OPEN_AI_CHAT_MODELS,
-)
 from mindsdb.integrations.libs.llm.utils import get_llm_config
 from mindsdb.integrations.utilities.handler_utils import get_api_key
 from mindsdb.integrations.utilities.rag.settings import DEFAULT_RAG_PROMPT_TEMPLATE
@@ -42,7 +39,8 @@ from .callback_handlers import LogCallbackHandler, ContextCaptureCallback
 from .langfuse_callback_handler import LangfuseCallbackHandler, get_skills
 from .safe_output_parser import SafeOutputParser
 
-from .constants import (
+from mindsdb.interfaces.agents.constants import (
+    OPEN_AI_CHAT_MODELS,
     DEFAULT_AGENT_TIMEOUT_SECONDS,
     DEFAULT_AGENT_TYPE,
     DEFAULT_EMBEDDINGS_MODEL_PROVIDER,
@@ -56,7 +54,8 @@ from .constants import (
     NVIDIA_NIM_CHAT_MODELS,
     USER_COLUMN,
     ASSISTANT_COLUMN,
-    CONTEXT_COLUMN, TRACE_ID_COLUMN
+    CONTEXT_COLUMN, TRACE_ID_COLUMN,
+    DEFAULT_AGENT_SYSTEM_PROMPT
 )
 from mindsdb.interfaces.skills.skill_tool import skill_tool, SkillData
 from langchain_anthropic import ChatAnthropic
@@ -175,6 +174,10 @@ def create_chat_model(args: Dict):
 
 def prepare_prompts(df, base_template, input_variables, user_column=USER_COLUMN):
     empty_prompt_ids = np.where(df[input_variables].isna().all(axis=1).values)[0]
+
+    # Combine system prompt with user-provided template
+    base_template = f"{DEFAULT_AGENT_SYSTEM_PROMPT}\n\n{base_template}"
+
     base_template = base_template.replace('{{', '{').replace('}}', '}')
     prompts = []
 
@@ -196,8 +199,9 @@ def prepare_callbacks(self, args):
     return callbacks, context_callback
 
 
-def handle_agent_error(e):
-    error_message = f"An error occurred during agent execution: {str(e)}"
+def handle_agent_error(e, error_message=None):
+    if error_message is None:
+        error_message = f"An error occurred during agent execution: {str(e)}"
     logger.error(error_message, exc_info=True)
     return error_message
 
@@ -526,7 +530,13 @@ AI: {response}"""
                 output = result['output'] if isinstance(result, dict) and 'output' in result else str(result)
                 return {CONTEXT_COLUMN: captured_context, ASSISTANT_COLUMN: output}
             except Exception as e:
-                return {CONTEXT_COLUMN: [], ASSISTANT_COLUMN: handle_agent_error(e)}
+                error_message = str(e)
+                # Special handling for API key errors
+                if "API key" in error_message and ("not found" in error_message or "missing" in error_message):
+                    # Format API key error more clearly
+                    logger.error(f"API Key Error: {error_message}")
+                    error_message = f"API Key Error: {error_message}"
+                return {CONTEXT_COLUMN: [], ASSISTANT_COLUMN: handle_agent_error(e, error_message)}
 
         completions = []
         contexts = []

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -2,6 +2,7 @@
     Wrapper around MindsDB's executor and integration controller following the implementation of the original
     langchain.sql_database.SQLDatabase class to partly replicate its behavior.
 """
+import traceback
 from typing import Any, Iterable, List, Optional
 
 from mindsdb.utilities import log
@@ -57,8 +58,20 @@ class MindsDBSQL(SQLDatabase):
         """Information about all tables in the database."""
         return self._sql_agent.get_table_info()
 
+    @property
+    def kb_info(self) -> str:
+        """Information about all knowledge bases in the database."""
+        return self._sql_agent.get_knowledge_base_info()
+
     def get_usable_table_names(self) -> Iterable[str]:
-        return self._sql_agent.get_usable_table_names()
+        """Information about all tables in the database."""
+        try:
+            return self._sql_agent.get_usable_table_names()
+        except Exception as e:
+            # If there's an error accessing tables through the integration, handle it gracefully
+            logger.warning(f"Error getting usable table names: {str(e)}")
+            # Return an empty list instead of raising an exception
+            return []
 
     def get_table_info_no_throw(self, table_names: Optional[List[str]] = None) -> str:
         for i in range(len(table_names)):
@@ -66,5 +79,91 @@ class MindsDBSQL(SQLDatabase):
         return self._sql_agent.get_table_info_safe(table_names)
 
     def run_no_throw(self, command: str, fetch: str = "all") -> str:
+        """Execute a SQL command and return the result as a string.
+
+        This method catches any exceptions and returns an error message instead of raising an exception.
+
+        Args:
+            command: The SQL command to execute
+            fetch: Whether to fetch 'all' results or just 'one'
+
+        Returns:
+            A string representation of the result or an error message
+        """
         command = extract_essential(command)
-        return self._sql_agent.query_safe(command)
+
+        try:
+
+            # Log the query for debugging
+            logger.info(f"Executing SQL query: {command}")
+
+            # remove backticks
+            command = command.replace('`', '')
+
+            # Parse the SQL string to an AST object first
+            from mindsdb_sql_parser import parse_sql
+            ast_query = parse_sql(command)
+
+            # Now execute the parsed query
+            result = self._sql_agent.skill_tool.get_command_executor().execute_command(ast_query, database_name="mindsdb")
+
+            # Convert ExecuteAnswer to a DataFrame for easier manipulation
+            df = None
+            if hasattr(result, 'data') and hasattr(result.data, 'data_frame'):
+                df = result.data.data_frame
+            else:
+                # Fallback to to_df when data_frame attr not available
+                try:
+                    df = result.data.to_df()
+                except Exception:
+                    df = None
+
+            # Default behaviour (string)
+            if df is not None:
+                if not df.empty:
+                    return df.to_string(index=False)
+                else:
+                    return "Query executed successfully, but returned no data."
+
+            return str(result)
+
+        except Exception as e:
+            logger.error(f"Error executing SQL command: {str(e)}\n{traceback.format_exc()}")
+            # If this is a knowledge base query, provide a more helpful error message
+            if "knowledge_base" in command.lower() or any(kb in command for kb in self._sql_agent.get_usable_knowledge_base_names()):
+                return f"Error executing knowledge base query: {str(e)}. Please check that the knowledge base exists and your query syntax is correct."
+            return f"Error: {str(e)}"
+
+    # def run_no_throw(self, command: str, fetch: str = "all") -> str:
+    #     """Execute a SQL command and return the result as a string.
+    #
+    #     This method catches any exceptions and returns an error message instead of raising an exception.
+    #
+    #     Args:
+    #         command: The SQL command to execute
+    #         fetch: Whether to fetch 'all' results or just 'one'
+    #
+    #     Returns:
+    #         A string representation of the result or an error message
+    #     """
+    #     command = extract_essential(command)
+    #     try:
+    #         return self._sql_agent.query_safe(command)
+    #     except Exception as e:
+    #         logger.error(f"Error executing SQL command: {str(e)}")
+    #         # If this is a knowledge base query, provide a more helpful error message
+    #         if "knowledge_base" in command.lower() or any(kb in command for kb in self._sql_agent.get_usable_knowledge_base_names()):
+    #             return f"Error executing knowledge base query: {str(e)}. Please check that the knowledge base exists and your query syntax is correct."
+    #         return f"Error: {str(e)}"
+
+    def get_usable_knowledge_base_names(self) -> List[str]:
+        """Get a list of usable knowledge base names.
+
+        Returns:
+            A list of knowledge base names that can be used in queries
+        """
+        try:
+            return self._sql_agent.get_usable_knowledge_base_names()
+        except Exception as e:
+            logger.error(f"Error getting usable knowledge base names: {str(e)}")
+            return []

mindsdb/interfaces/database/projects.py

@@ -4,7 +4,6 @@ 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
@@ -457,7 +456,7 @@ class ProjectController:
         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:
+    def update(self, id: Optional[int] = None, name: Optional[str] = None, new_name: str = 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")
 
@@ -470,10 +469,5 @@ class ProjectController:
             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/functions/controller.py

@@ -1,7 +1,7 @@
 import os
+import copy
 
 from duckdb.typing import BIGINT, DOUBLE, VARCHAR, BLOB, BOOLEAN
-from mindsdb.interfaces.functions.to_markdown import ToMarkdown
 from mindsdb.interfaces.storage.model_fs import HandlerStorage
 from mindsdb.utilities.config import config
 
@@ -159,31 +159,28 @@ class FunctionController(BYOMFunctionsController):
         return meta
 
     def to_markdown_call_function(self, node):
+        # load on-demand because lib is heavy
+        from mindsdb.interfaces.functions.to_markdown import ToMarkdown
         name = node.op.lower()
 
         if name in self.callbacks:
             return self.callbacks[name]
 
-        def callback(file_path_or_url, use_llm):
+        def callback(file_path_or_url):
             chat_model_params = self._parse_chat_model_params('TO_MARKDOWN_FUNCTION_')
 
-            llm_client = None
-            llm_model = None
-            try:
-                from mindsdb.interfaces.agents.langchain_agent import create_chat_model
-                llm = create_chat_model(chat_model_params)
-                llm_client = llm.root_client
-                llm_model = llm.model_name
-            except Exception:
-                pass
+            params_copy = copy.deepcopy(chat_model_params)
+            params_copy['model'] = params_copy.pop('model_name')
+            params_copy.pop('api_keys')
+            params_copy.pop('provider')
 
-            to_markdown = ToMarkdown(use_llm, llm_client, llm_model)
-            return to_markdown.call(file_path_or_url)
+            to_markdown = ToMarkdown()
+            return to_markdown.call(file_path_or_url, **params_copy)
 
         meta = {
             'name': name,
             'callback': callback,
-            'input_types': ['str', 'bool'],
+            'input_types': ['str'],
             'output_type': 'str'
         }
         self.callbacks[name] = meta

mindsdb/interfaces/functions/to_markdown.py

@@ -1,13 +1,10 @@
-import base64
 from io import BytesIO
 import os
 from typing import Union
 from urllib.parse import urlparse
 
-import fitz  # PyMuPDF
-from markitdown import MarkItDown
+from aipdf import ocr
 import mimetypes
-from openai import OpenAI
 import requests
 
 
@@ -15,41 +12,22 @@ class ToMarkdown:
     """
     Extracts the content of documents of various formats in markdown format.
     """
-    def __init__(self, use_llm: bool, llm_client: OpenAI = None, llm_model: str = None):
+    def __init__(self):
         """
         Initializes the ToMarkdown class.
         """
-        # If use_llm is True, llm_client and llm_model must be provided.
-        if use_llm and (llm_client is None or llm_model is None):
-            raise ValueError('LLM client and model must be provided when use_llm is True.')
 
-        # If use_llm is False, set llm_client and llm_model to None even if they are provided.
-        if not use_llm:
-            llm_client = None
-            llm_model = None
-
-        # Only OpenAI is supported for now.
-        # TODO: Add support for other LLMs.
-        if llm_client is not None and not isinstance(llm_client, OpenAI):
-            raise ValueError('Only OpenAI models are supported at the moment.')
-
-        self.use_llm = use_llm
-        self.llm_client = llm_client
-        self.llm_model = llm_model
-
-    def call(self, file_path_or_url: str) -> str:
+    def call(self, file_path_or_url: str, **kwargs) -> str:
         """
         Converts a file to markdown.
         """
         file_extension = self._get_file_extension(file_path_or_url)
-        file = self._get_file_content(file_path_or_url)
+        file_content = self._get_file_content(file_path_or_url)
 
         if file_extension == '.pdf':
-            return self._pdf_to_markdown(file)
-        elif file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
-            return self._image_to_markdown(file)
+            return self._pdf_to_markdown(file_content, **kwargs)
         else:
-            return self._other_to_markdown(file)
+            raise ValueError(f"Unsupported file type: {file_extension}.")
 
     def _get_file_content(self, file_path_or_url: str) -> str:
         """
@@ -90,105 +68,12 @@ class ToMarkdown:
         else:
             return os.path.splitext(file_path_or_url)[1]
 
-    def _pdf_to_markdown(self, file_content: Union[requests.Response, bytes]) -> str:
+    def _pdf_to_markdown(self, file_content: Union[requests.Response, bytes], **kwargs) -> str:
         """
         Converts a PDF file to markdown.
         """
-        if self.llm_client is None:
-            return self._pdf_to_markdown_no_llm(file_content)
-        else:
-            return self._pdf_to_markdown_llm(file_content)
-
-    def _pdf_to_markdown_llm(self, file_content: Union[requests.Response, BytesIO]) -> str:
-        """
-        Converts a PDF file to markdown using LLM.
-        The LLM is used mainly for the purpose of generating descriptions of any images in the PDF.
-        """
         if isinstance(file_content, requests.Response):
             file_content = BytesIO(file_content.content)
 
-        document = fitz.open(stream=file_content, filetype="pdf")
-
-        markdown_content = []
-        for page_num in range(len(document)):
-            page = document.load_page(page_num)
-
-            # Get text blocks with coordinates.
-            page_content = []
-            blocks = page.get_text("blocks")
-            for block in blocks:
-                x0, y0, x1, y1, text, _, _ = block
-                if text.strip():  # Skip empty or whitespace blocks.
-                    page_content.append((y0, text.strip()))
-
-            # Extract images from the page.
-            image_list = page.get_images(full=True)
-            for img_index, img in enumerate(image_list):
-                xref = img[0]
-                base_image = document.extract_image(xref)
-                image_bytes = base_image["image"]
-
-                # Use actual image y-coordinate if available.
-                y0 = float(base_image.get("y", 0))
-                image_description = self._generate_image_description(image_bytes)
-                page_content.append((y0, f"![{image_description}](image_{page_num + 1}_{img_index + 1}.png)"))
-
-            # Sort the content by y0 coordinate
-            page_content.sort(key=lambda x: x[0])
-
-            # Add sorted content to the markdown
-            for _, text in page_content:
-                markdown_content.append(text)
-            markdown_content.append("\n")
-
-        document.close()
-
-        return "\n".join(markdown_content)
-
-    def _generate_image_description(self, image_bytes: bytes) -> str:
-        """
-        Generates a description of the image using LLM.
-        """
-        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
-
-        response = self.llm_client.chat.completions.create(
-            model=self.llm_model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": "Describe this image"},
-                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
-                    ],
-                }
-            ],
-        )
-        description = response.choices[0].message.content
-        return description
-
-    def _pdf_to_markdown_no_llm(self, file_content: Union[requests.Response, BytesIO]) -> str:
-        """
-        Converts a PDF file to markdown without using LLM.
-        """
-        md = MarkItDown(enable_plugins=True)
-        result = md.convert(file_content)
-        return result.markdown
-
-    def _image_to_markdown(self, file_content: Union[requests.Response, BytesIO]) -> str:
-        """
-        Converts images to markdown.
-        """
-        if not self.use_llm or self.llm_client is None:
-            raise ValueError('LLM client must be enabled to convert images to markdown.')
-
-        md = MarkItDown(llm_client=self.llm_client, llm_model=self.llm_model, enable_plugins=True)
-        result = md.convert(file_content)
-        return result.markdown
-
-    def _other_to_markdown(self, file_content: Union[requests.Response, BytesIO]) -> str:
-        """
-        Converts other file formats to markdown.
-        """
-        md = MarkItDown(enable_plugins=True)
-        result = md.convert(file_content)
-        return result.markdown
+        markdown_pages = ocr(file_content, **kwargs)
+        return "\n\n---\n\n".join(markdown_pages)