langchain-ocr-lib 0.1.0__py3-none-any.whl

langchain_ocr_lib/chains/chain.py

@@ -0,0 +1,55 @@
+"""Module for the base class of chains."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.runnables.utils import Input, Output
+
+
+class Chain(Runnable[Input, Output], ABC):
+    """Base class for chains."""
+
+    @abstractmethod
+    async def ainvoke(self, chain_input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) -> Output:
+        """Asynchronously invoke the chain with the given input and configuration.
+
+        Parameters
+        ----------
+        chain_input : Input
+            The input data required to asynchronously invoke the chain.
+        config : Optional[RunnableConfig], optional
+            The configuration settings for the chain invocation, by default None.
+        **kwargs : Any
+            Additional keyword arguments that may be required for the chain invocation.
+
+        Returns
+        -------
+        Output
+            The result of the chain invocation.
+        """
+
+    @abstractmethod
+    def invoke(self, chain_input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) -> Output:
+        """
+        Invoke the chain with the given input and configuration.
+
+            Typing indicates `Output` will be the return, but because no implementation is planned,
+            this will never be returned. This method is not implemented and will raise a not implemented error.
+
+        Notes
+        -----
+        This method should never be called. It exists only because the base class requires an implementation.
+
+        Parameters
+        ----------
+        chain_input : Input
+            The input data required to invoke the chain.
+        config : Optional[RunnableConfig], optional
+            The configuration settings for the chain invocation, by default None.
+
+        Returns
+        -------
+        Output
+            The result of the chain invocation.
+        """

langchain_ocr_lib/converter/converter.py

@@ -0,0 +1,52 @@
+"""Module for the File2MarkdownConverter class."""
+
+from abc import ABC, abstractmethod
+import inject
+
+
+class File2MarkdownConverter(ABC):
+    """Abstract base class for the File2MarkdownConverter class."""
+
+    _chain = inject.attr("LangfuseTracedChain")
+
+    @abstractmethod
+    async def aconvert2markdown(self, file: bytes) -> str:
+        """Asynchronously convert file to markdown format.
+
+        Parameters
+        ----------
+        file : bytes
+            The file to convert.
+
+        Returns
+        -------
+        str
+            The markdown representation of the file.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not implemented.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def convert2markdown(self, file: bytes) -> str:
+        """Convert file to markdown format.
+
+        Parameters
+        ----------
+        file : bytes
+            The file to convert.
+
+        Returns
+        -------
+        str
+            The markdown representation of the file.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not implemented.
+        """
+        raise NotImplementedError

langchain_ocr_lib/di_config.py

@@ -0,0 +1,86 @@
+"""Module containing the dependency injection container for managing application dependencies."""
+
+from inject import Binder
+import inject
+from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
+from langfuse import Langfuse
+
+from langchain_ocr_lib.impl.chains.ocr_chain import OcrChain
+from langchain_ocr_lib.impl.settings.ollama_chat_settings import OllamaSettings
+from langchain_ocr_lib.impl.settings.openai_chat_settings import OpenAISettings
+from langchain_ocr_lib.impl.settings.llm_class_type_settings import LlmClassTypeSettings
+from langchain_ocr_lib.impl.settings.langfuse_settings import LangfuseSettings
+from langchain_ocr_lib.impl.settings.language_settings import LanguageSettings
+from langchain_ocr_lib.impl.tracers.langfuse_traced_chain import LangfuseTracedChain
+from langchain_ocr_lib.prompt_templates.ocr_prompt import ocr_prompt_template_builder
+from langchain_ocr_lib.impl.llms.llm_factory import llm_provider
+from langchain_ocr_lib.impl.langfuse_manager.langfuse_manager import LangfuseManager
+from langchain_ocr_lib.impl.converter.pdf_converter import Pdf2MarkdownConverter
+from langchain_ocr_lib.impl.converter.image_converter import Image2MarkdownConverter
+
+
+def lib_di_config(binder: Binder):
+    """Configure dependency injection bindings for the OCR library.
+
+    Parameters
+    ----------
+    binder : Binder
+        The dependency injection binder instance used to register the bindings.
+
+    Raises
+    ------
+    NotImplementedError
+        If the configured LLM type is not implemented.
+
+    """
+    langfuse_settings = LangfuseSettings()
+    llm_class_type_settings = LlmClassTypeSettings()
+    language_settings = LanguageSettings()
+
+    if llm_class_type_settings.llm_type == "ollama":
+        settings = OllamaSettings()
+        llm_instance = llm_provider(settings, ChatOllama)
+    elif llm_class_type_settings.llm_type == "openai":
+        settings = OpenAISettings()
+        llm_instance = llm_provider(settings, ChatOpenAI)
+    else:
+        raise NotImplementedError("Configured LLM is not implemented")
+    binder.bind("LargeLanguageModel", llm_instance)
+
+    prompt = ocr_prompt_template_builder(language=language_settings.language, model_name=settings.model)
+
+    binder.bind(
+        "LangfuseClient",
+        Langfuse(
+            public_key=langfuse_settings.public_key,
+            secret_key=langfuse_settings.secret_key,
+            host=langfuse_settings.host,
+        ),
+    )
+
+    binder.bind(
+        "LangfuseManager",
+        LangfuseManager(
+            managed_prompts={
+                OcrChain.__name__: prompt,
+            },
+        ),
+    )
+
+    binder.bind("OcrChain", OcrChain())
+
+    binder.bind(
+        "LangfuseTracedChain",
+        LangfuseTracedChain(
+            settings=langfuse_settings,
+        ),
+    )
+
+    binder.bind("PdfConverter", Pdf2MarkdownConverter())
+    binder.bind("ImageConverter", Image2MarkdownConverter())
+
+
+def configure_di():
+    """Configure dependency injection using the `inject` library."""
+    inject.configure(lib_di_config, allow_override=True, clear=True)

langchain_ocr_lib/impl/chains/ocr_chain.py

@@ -0,0 +1,86 @@
+"""Module for LLM answer generation chain."""
+
+from typing import Any, Optional
+
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.runnables.utils import Input
+import inject
+
+from langchain_ocr_lib.chains.chain import Chain
+
+RunnableInput = Input  # TODO: adjust properly
+RunnableOutput = str
+
+
+class OcrChain(Chain[RunnableInput, RunnableOutput]):
+    """Base class for LLM answer generation chain."""
+
+    _langfuse_manager = inject.attr("LangfuseManager")
+
+    def __init__(self):
+        """Initialize the AnswerGenerationChain.
+
+        Parameters
+        ----------
+        langfuse_manager : LangfuseManager
+            Manager instance for handling Langfuse operations and monitoring
+        """
+
+    async def ainvoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Asynchronously invokes the chain with given input.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        chain_config : Optional[RunnableConfig]
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments passed to the chain.
+
+        Returns
+        -------
+        RunnableOutput
+            The output generated by the chain.
+
+        Raises
+        ------
+        ChainError
+            If an error occurs during chain execution.
+        """
+        return await self._create_chain().ainvoke(chain_input, config=config)
+
+    def invoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Invoke the chain with given input.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        chain_config : Optional[RunnableConfig]
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments passed to the chain.
+
+        Returns
+        -------
+        RunnableOutput
+            The output generated by the chain.
+
+        Raises
+        ------
+        ChainError
+            If an error occurs during chain execution.
+        """
+        return self._create_chain().invoke(chain_input, config=config)
+
+    def _create_chain(self) -> Runnable:
+        return self._langfuse_manager.get_base_prompt(self.__class__.__name__) | self._langfuse_manager.get_base_llm(
+            self.__class__.__name__
+        )

langchain_ocr_lib/impl/converter/image_converter.py

@@ -0,0 +1,88 @@
+"""Module for converting an image to markdown using a Langchain chain."""
+
+import io
+import base64
+from PIL import Image
+from PIL.ImageFile import ImageFile
+
+from langchain_ocr_lib.converter.converter import File2MarkdownConverter
+
+
+class Image2MarkdownConverter(File2MarkdownConverter):
+    """Converts an image to markdown using a Langchain chain."""
+
+    async def aconvert2markdown(self, file: ImageFile | None = None, filename: str | None = None) -> str:
+        """
+        Asynchronously converts an image to markdown using a Langchain chain.
+
+        Parameters
+        ----------
+        file : ImageFile | None, optional
+            PIL Image object to convert, by default None
+        filename : str | None, optional
+            Path to the image file to convert, by default None
+
+        Returns
+        -------
+        str
+            Markdown representation of the image.
+
+        Raises
+        ------
+        ValueError
+            If no file or filename is provided.
+        ValueError
+            If the file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                file = Image.open(filename)
+            except Exception as e:
+                raise ValueError("Image corrupted or unsupported file type, %s" % e)
+
+        buf = io.BytesIO()
+        file.save(buf, format="PNG")
+        base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+        response = await self._chain.ainvoke({"image_data": base64_img})
+
+        return response.content
+
+    def convert2markdown(self, file: ImageFile | None = None, filename: str | None = None) -> str:
+        """
+        Convert an image to markdown using a Langchain chain.
+
+        Parameters
+        ----------
+        file : ImageFile | None, optional
+            PIL Image object to convert, by default None
+        filename : str | None, optional
+            Path to the image file to convert, by default None
+
+        Returns
+        -------
+        str
+            Markdown representation of the image.
+
+        Raises
+        ------
+        ValueError
+            If no file or filename is provided.
+        ValueError
+            If the file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                file = Image.open(filename)
+            except Exception as e:
+                raise ValueError("Image corrupted or unsupported file type, %s" % e)
+
+        buf = io.BytesIO()
+        file.save(buf, format="PNG")
+        base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+        response = self._chain.invoke({"image_data": base64_img})
+
+        return response.content

langchain_ocr_lib/impl/converter/pdf_converter.py

@@ -0,0 +1,105 @@
+"""Module for converting PDF files to markdown."""
+
+from pdf2image import convert_from_bytes
+import io
+import base64
+
+from langchain_ocr_lib.converter.converter import File2MarkdownConverter
+
+
+class Pdf2MarkdownConverter(File2MarkdownConverter):
+    """Converts PDF files to markdown format.
+
+    This class provides methods to convert PDF files, either provided as bytes or by filename,
+    into markdown format.
+
+    Attributes
+    ----------
+    _chain : Chain
+        The OCR chain used to process images.
+    """
+
+    async def aconvert2markdown(self, file: bytes | None = None, filename: str | None = None) -> str:
+        """Asynchronously converts a PDF file (either provided as bytes or by filename) into markdown.
+
+        Parameters
+        ----------
+        file : bytes, optional
+            The PDF file as bytes. Defaults to None.
+        filename : str, optional
+            The path to the PDF file. Defaults to None.
+
+        Returns
+        -------
+        str
+            The markdown representation of the PDF content extracted via OCR.
+
+        Raises
+        ------
+        ValueError
+            If neither `file` nor `filename` is provided.
+        ValueError
+            If the PDF file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                with open(filename, "rb") as f:
+                    file = f.read()
+            except Exception as e:
+                raise ValueError("PDF corrupted or unsupported file type, %s" % e)
+
+        images = convert_from_bytes(file)
+
+        markdown = ""
+        for image in images:
+            # Wrap the image in a Document if your chain expects it.
+            buf = io.BytesIO()
+            image.save(buf, format="PNG")
+            base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+            response = await self._chain.ainvoke({"image_data": base64_img})
+            markdown += response.content
+        return markdown
+
+    def convert2markdown(self, file: bytes | None = None, filename: str | None = None) -> str:
+        """Convert a PDF file (either provided as bytes or by filename) into markdown.
+
+        Parameters
+        ----------
+        file : bytes, optional
+            The PDF file as bytes. Defaults to None.
+        filename : str, optional
+            The path to the PDF file. Defaults to None.
+
+        Returns
+        -------
+        str
+            The markdown representation of the PDF content extracted via OCR.
+
+        Raises
+        ------
+        ValueError
+            If neither `file` nor `filename` is provided.
+        ValueError
+            If the PDF file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                with open(filename, "rb") as f:
+                    file = f.read()
+            except Exception as e:
+                raise ValueError("PDF corrupted or unsupported file type") from e
+
+        images = convert_from_bytes(file)
+
+        markdown = ""
+        for image in images:
+            buf = io.BytesIO()
+            image.save(buf, format="PNG")
+            base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+            response = self._chain.invoke({"image_data": base64_img})
+            markdown += response.content
+        return markdown

langchain_ocr_lib/impl/langfuse_manager/langfuse_manager.py

@@ -0,0 +1,149 @@
+# spell-checker: disable
+"""Module for managing Langfuse prompts and Langfuse Language Models (LLMs)."""
+import logging
+from typing import Optional
+import inject
+import json
+
+from langchain.prompts import ChatPromptTemplate
+from langchain_core.language_models.llms import LLM
+from langfuse.api.resources.commons.errors.not_found_error import NotFoundError
+from langfuse.model import ChatPromptClient
+
+logger = logging.getLogger(__name__)
+
+
+class LangfuseManager:
+    """Manage prompts using Langfuse and a Large Language Model (LLM).
+
+    Attributes
+    ----------
+    API_KEY_FILTER : str
+        A filter string used to exclude the API key from configurations.
+    """
+
+    API_KEY_FILTER: str = "api_key"
+    _llm = inject.attr("LargeLanguageModel")
+    _langfuse = inject.attr("LangfuseClient")
+
+    def __init__(
+        self,
+        managed_prompts: dict[str, str],
+    ):
+        self._managed_prompts = managed_prompts
+
+    def init_prompts(self) -> None:
+        """
+        Initialize the prompts managed by the LangfuseManager.
+
+        This method iterates over the keys of the managed prompts and retrieves
+        each prompt using the `get_langfuse_prompt` method.
+
+        Returns
+        -------
+        None
+        """
+        for key in list(self._managed_prompts.keys()):
+            self.get_langfuse_prompt(key)
+
+    def get_langfuse_prompt(self, base_prompt_name: str) -> Optional[ChatPromptClient]:
+        """
+        Retrieve the prompt from Langfuse Prompt Management.
+
+        Parameters
+        ----------
+        base_prompt_name : str
+            The name of the base prompt to retrieve.
+
+        Returns
+        -------
+        Optional[TextPromptClient]
+            The Langfuse prompt template if found, otherwise None.
+
+        Raises
+        ------
+        NotFoundError
+            If the prompt is not found in Langfuse, a new prompt is created.
+        Exception
+            If an error occurs while retrieving the prompt template from Langfuse.
+        """
+        try:
+            langfuse_prompt = self._langfuse.get_prompt(base_prompt_name)
+        except NotFoundError:
+            logger.info("Prompt not found in LangFuse. Creating new.")
+            llm_configurable_configs = {
+                config.id: config.default for config in self._llm.config_specs if self.API_KEY_FILTER not in config.id
+            }
+            self._langfuse.create_prompt(
+                name=base_prompt_name,
+                prompt=self._managed_prompts[base_prompt_name],
+                config=llm_configurable_configs,
+                labels=["production"],
+                type="chat",
+            )
+            langfuse_prompt = self._langfuse.get_prompt(base_prompt_name)
+        except Exception as error:
+            logger.error(
+                "Error occured while getting prompt template from langfuse. Error:\n{error}",
+                extra={error: error},
+            )
+            return None
+        return langfuse_prompt
+
+    def get_base_llm(self, name: str) -> LLM:
+        """
+        Get the Langfuse prompt, the configuration as well as Large Language Model (LLM).
+
+        Parameters
+        ----------
+        name : str
+            The name of the Langfuse prompt to retrieve the configuration for.
+
+        Returns
+        -------
+        LLM
+            The base Large Language Model. If the Langfuse prompt is not found,
+            returns the LLM with a fallback configuration.
+        """
+        langfuse_prompt = self.get_langfuse_prompt(name)
+        if not langfuse_prompt:
+            logger.error("Using fallback for llm")
+            return self._llm
+
+        return self._llm.with_config({"configurable": langfuse_prompt.config})
+
+    def get_base_prompt(self, name: str) -> ChatPromptTemplate:
+        """
+        Retrieve the base prompt from Langfuse Prompt Management.
+
+        Parameters
+        ----------
+        name : str
+            The name of the prompt to retrieve.
+
+        Returns
+        -------
+        PromptTemplate
+            The base prompt template.
+
+        Notes
+        -----
+        If the prompt cannot be retrieved from Langfuse, a fallback value is used.
+        """
+        langfuse_prompt = self.get_langfuse_prompt(name)
+        if not langfuse_prompt:
+            logger.error("Could not retrieve prompt template from langfuse. Using fallback value.")
+            fallback = self._managed_prompts[name]
+            if isinstance(fallback, ChatPromptTemplate):
+                return fallback
+            if isinstance(fallback, list) and len(fallback) > 0 and isinstance(fallback[0], dict) and "content" in fallback[0]:
+                image_payload = [{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,{image_data}"}}]
+                return ChatPromptTemplate.from_messages([("system", fallback[0]["content"]), ("user", image_payload)])
+            else:
+                logger.error("Unexpected structure for fallback prompt.")
+                raise ValueError("Unexpected structure for fallback prompt.")
+        langchain_prompt = langfuse_prompt.get_langchain_prompt()
+
+        langchain_prompt[-1] = ("user", json.loads(langchain_prompt[-1][1]))
+
+        return ChatPromptTemplate.from_messages(langchain_prompt)

langchain_ocr_lib/impl/llms/llm_factory.py

@@ -0,0 +1,66 @@
+"""Module for creating LLM instances from settings and the LLM class."""
+
+from typing import Callable, Type
+
+from langchain_community.llms.ollama import Ollama
+from langchain_core.language_models.llms import LLM
+from langchain_core.runnables import ConfigurableField
+from pydantic_settings import BaseSettings
+
+
+def _generic_llm_factory(
+    llm_class: Type[LLM],
+    configurable_fields: dict[str, ConfigurableField],
+) -> Callable[[BaseSettings], LLM]:
+    def factory(settings: BaseSettings) -> LLM:
+        llm_instance = llm_class(**settings.model_dump())
+        return llm_instance.configurable_fields(**configurable_fields)
+
+    return factory
+
+
+def get_configurable_fields_from(settings: BaseSettings) -> dict[str, ConfigurableField]:
+    """
+    Extract configurable fields from the given settings.
+
+    Parameters
+    ----------
+    settings : BaseSettings
+        An instance of BaseSettings containing model fields with their respective settings.
+
+    Returns
+    -------
+    dict[str, ConfigurableField]
+        A dictionary where the keys are field names and the values are ConfigurableField instances
+        with the field's id and name set based on the settings.
+
+    Notes
+    -----
+    Only fields with a non-None title in their settings are included in the returned dictionary.
+    """
+    _fields = {}
+    for field_name in settings.model_fields:
+        settings_of_interest = settings.model_fields[field_name]
+        if settings_of_interest.title is not None:
+            _fields[field_name] = ConfigurableField(id=field_name, name=settings_of_interest.title)
+    return _fields
+
+
+def llm_provider(settings: BaseSettings, llm_cls: Type[LLM] = Ollama) -> LLM:
+    """
+    Create an instance of a LLM provider based on the given settings and class type.
+
+    Parameters
+    ----------
+    settings : BaseSettings
+        Configuration settings for the LLM.
+    llm_cls : Type[LLM], optional
+        The class type of the LLM to instantiate (default Ollama).
+
+    Returns
+    -------
+    LLM
+        An instance of the specified language model provider.
+    """
+    provider = _generic_llm_factory(llm_cls, get_configurable_fields_from(settings))
+    return provider(settings)

langchain_ocr_lib/impl/llms/llm_type.py

@@ -0,0 +1,11 @@
+"""Module containing the Large Language Model (LLM) type enum class."""
+
+from enum import StrEnum, unique
+
+
+@unique
+class LLMType(StrEnum):
+    """Enum class representing different types of Large Language Models (LLMs)."""
+
+    OLLAMA = "ollama"
+    OPENAI = "openai"

langchain_ocr_lib/impl/settings/langfuse_settings.py

@@ -0,0 +1,29 @@
+"""Contains settings regarding Langfuse."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class LangfuseSettings(BaseSettings):
+    """
+    Contains settings regarding Langfuse.
+
+    Attributes
+    ----------
+    secret_key : str
+        The secret key for Langfuse.
+    public_key : str
+        The public key for Langfuse.
+    host : str
+        The host for Langfuse.
+    """
+
+    class Config:
+        """Config class for reading Fields from env."""
+
+        env_prefix = "LANGFUSE_"
+        case_sensitive = False
+
+    secret_key: str = Field(default="", description="The secret key for Langfuse.")
+    public_key: str = Field(default="", description="The public key for Langfuse.")
+    host: str = Field(default="https://api.langchain.com", description="The host for Langfuse.")

langchain_ocr_lib/impl/settings/language_settings.py

@@ -0,0 +1,25 @@
+"""Module containing the LanguageSettings class."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class LanguageSettings(BaseSettings):
+    """
+    Contains settings regarding the language used for OCR.
+
+    Attributes
+    ----------
+    language : str
+        The language to use for OCR.
+    """
+
+    class Config:
+        """Config class for reading fields from environment variables."""
+
+        env_prefix = "OCR_"
+        case_sensitive = False
+
+    language: str = Field(
+        default="en", description="The language in iso 639-1 format, e.g. 'en' for English, 'de' for German, etc."
+    )

langchain_ocr_lib/impl/settings/llm_class_type_settings.py

@@ -0,0 +1,27 @@
+"""Module for the LLM class type settings."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+from langchain_ocr_lib.impl.llms.llm_type import LLMType
+
+
+class LlmClassTypeSettings(BaseSettings):
+    """Settings for the LLM class type.
+
+    Attributes
+    ----------
+    llm_type : LLMType
+        The type of LLM to use. Defaults to LLMType.OLLAMA.
+
+    """
+
+    class Config:
+        """Config class for reading Fields from env."""
+
+        env_prefix = "RAG_CLASS_TYPE_"
+        case_sensitive = False
+
+    llm_type: LLMType = Field(
+        default=LLMType.OLLAMA,
+    )

langchain_ocr_lib/impl/settings/ollama_chat_settings.py

@@ -0,0 +1,42 @@
+"""Module that contains settings regarding the LLM."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OllamaSettings(BaseSettings):
+    """
+    Contains settings regarding the LLM.
+
+    Attributes
+    ----------
+    model : str
+      The model name to be used.
+    base_url : str
+      The base URL for the LLM.
+    top_k : int
+      Reduces the probability of generating nonsense. A higher value (e.g. 100) will give more diverse answers,
+      while a lower value (e.g. 10) will be more conservative.
+    top_p : float
+      Works together with top-k. A higher value (e.g., 0.95) will lead to more diverse text,
+      while a lower value (e.g., 0.5) will generate more focused and conservative text.
+    temperature : float
+      The temperature of the model. Increasing the temperature will make the model answer more creatively.
+
+    Notes
+    -----
+    If the title of a field is provided, the field will be configurable in the Langfuse UI
+    the field names should match the names of the attributes in the corresponding LLM class!
+    """
+
+    class Config:
+        """Config class for reading Fields from env."""
+
+        env_prefix = "OLLAMA_"
+        case_sensitive = False
+
+    model: str = Field(default="gemma3:4b-it-q4_K_M")
+    base_url: str = Field(default="http://localhost:11434")
+    top_k: int = Field(default=0, title="LLM Top K")
+    top_p: float = Field(default=0, title="LLM Top P")
+    temperature: float = Field(default=0, title="LLM Temperature")

langchain_ocr_lib/impl/settings/openai_chat_settings.py

@@ -0,0 +1,35 @@
+"""Module contains settings regarding the OpenAI API."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OpenAISettings(BaseSettings):
+    """
+    Contains settings regarding the OpenAI API.
+
+    Attributes
+    ----------
+    model : str
+        The model identifier.
+    api_key : str
+        The API key for authentication.
+    top_p : float
+        Total probability mass of tokens to consider at each step.
+    temperature : float
+        What sampling temperature to use.
+    vision_capable : bool
+        Flag to enable a vision capable model.
+    """
+
+    class Config:
+        """Config class for reading fields from environment variables."""
+
+        env_prefix = "OPENAI_"
+        case_sensitive = False
+
+    model: str = Field(default="gpt-4o-mini-search-preview-2025-03-11", description="The model identifier")
+    api_key: str = Field(default="", description="The API key for authentication")
+    top_p: float = Field(default=1.0, description="Total probability mass of tokens to consider at each step")
+    temperature: float = Field(default=0.7, description="What sampling temperature to use")
+    vision_capable: bool = Field(default=False, description="Enable a vision capable model")

langchain_ocr_lib/impl/tracers/langfuse_traced_chain.py

@@ -0,0 +1,44 @@
+"""Module for the LangfuseTraceChain class."""
+
+from typing import Optional
+
+import inject
+from langchain_core.runnables import RunnableConfig
+from langfuse.callback import CallbackHandler
+
+from langchain_ocr_lib.impl.settings.langfuse_settings import LangfuseSettings
+from langchain_ocr_lib.tracers.traced_chain import TracedChain
+
+
+class LangfuseTracedChain(TracedChain):
+    """A class to trace the execution of a Runnable using Langfuse.
+
+    This class wraps an inner Runnable and adds tracing capabilities using the Langfuse tracer.
+    It allows for the configuration of the tracer through the provided settings.
+
+    Attributes
+    ----------
+    CONFIG_CALLBACK_KEY : str
+        The key used to store callbacks in the configuration.
+    """
+
+    CONFIG_CALLBACK_KEY = "callbacks"
+    _inner_chain = inject.attr("OcrChain")
+
+    def __init__(self, settings: LangfuseSettings):
+        super().__init__()
+        self._settings = settings
+
+    def _add_tracing_callback(self, session_id: str, config: Optional[RunnableConfig]) -> RunnableConfig:
+        handler = CallbackHandler(
+            public_key=self._settings.public_key,
+            secret_key=self._settings.secret_key,
+            host=self._settings.host,
+            session_id=session_id,
+        )
+        if not config:
+            return RunnableConfig(callbacks=[handler])
+
+        current_callbacks = config.get(self.CONFIG_CALLBACK_KEY, [])
+        config[self.CONFIG_CALLBACK_KEY] = (current_callbacks if current_callbacks else []) + [handler]
+        return config

langchain_ocr_lib/language_mapping/language_mapping.py

@@ -0,0 +1,19 @@
+"""Module to map language codes to language names using pycountry."""
+
+import pycountry
+
+
+def get_language_name_from_pycountry(code: str) -> str:
+    """Given a language abbreviation (ISO 639-1), return the full language name in English using pycountry."""
+    language = pycountry.languages.get(alpha_2=code.lower())
+    if language:
+        # Sometimes language.name may include extra parts, adjust as needed.
+        return language.name.lower()
+    return None
+
+
+# Example usage:
+if __name__ == "__main__":
+    lang_codes = ["en", "de", "ru", "it", "es", "zh", "ja", "fr"]
+    for lang_code in lang_codes:
+        print(f"pycountry: {lang_code} -> {get_language_name_from_pycountry(lang_code)}")

langchain_ocr_lib/main.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+"""Command-line interface for langchain-ocr-lib package."""
+
+import argparse
+import asyncio
+import os
+import sys
+from typing import Optional
+
+from langchain_ocr_lib.di_config import configure_di
+import inject
+from langchain_ocr_lib.impl.converter.image_converter import Image2MarkdownConverter
+from langchain_ocr_lib.impl.converter.pdf_converter import Pdf2MarkdownConverter
+
+
+def setup() -> None:
+    """Initialize the dependency injection configuration."""
+    configure_di()
+
+
+async def convert_image_file(file_path: str, output_file: Optional[str] = None) -> str:
+    """Convert an image file to markdown text.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to the image file
+    output_file : Optional[str]
+        Path to save the markdown output, if None prints to stdout
+
+    Returns
+    -------
+    str
+        The markdown text
+    """
+    if not os.path.exists(file_path):
+        print(f"Error: File {file_path} not found", file=sys.stderr)
+        sys.exit(1)
+
+    converter = inject.instance(Image2MarkdownConverter)
+
+    # Pass the filename directly to the converter
+    result = await converter.aconvert2markdown(file=None, filename=file_path)
+
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(result)
+        print(f"Markdown saved to {output_file}")
+    else:
+        print(result)
+
+    return result
+
+
+async def convert_pdf_file(file_path: str, output_file: Optional[str] = None) -> str:
+    """Convert a PDF file to markdown text.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to the PDF file
+    output_file : Optional[str]
+        Path to save the markdown output, if None prints to stdout
+
+    Returns
+    -------
+    str
+        The markdown text
+    """
+    if not os.path.exists(file_path):
+        print(f"Error: File {file_path} not found", file=sys.stderr)
+        sys.exit(1)
+
+    converter = inject.instance(Pdf2MarkdownConverter)
+
+    # Pass the filename directly to the converter
+    result = await converter.aconvert2markdown(file=None, filename=file_path)
+
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(result)
+        print(f"Markdown saved to {output_file}")
+    else:
+        print(result)
+
+    return result
+
+
+def main():
+    """Run the CLI application."""
+    parser = argparse.ArgumentParser(description="Convert images or PDFs to Markdown")
+    parser.add_argument("file", help="Path to the image or PDF file")
+    parser.add_argument("-o", "--output", help="Output file path (default: print to stdout)", default=None)
+    parser.add_argument(
+        "-t", "--type", choices=["auto", "image", "pdf"], default="auto", help="File type (default: auto-detect)"
+    )
+
+    args = parser.parse_args()
+
+    # Setup dependency injection
+    setup()
+
+    file_type = args.type
+    if file_type == "auto":
+        if args.file.lower().endswith((".jpg", ".jpeg", ".png", ".gif", ".bmp")):
+            file_type = "image"
+        elif args.file.lower().endswith(".pdf"):
+            file_type = "pdf"
+        else:
+            print(f"Error: Could not detect file type of {args.file}", file=sys.stderr)
+            sys.exit(1)
+
+    if file_type == "image":
+        asyncio.run(convert_image_file(args.file, args.output))
+    elif file_type == "pdf":
+        asyncio.run(convert_pdf_file(args.file, args.output))
+
+
+if __name__ == "__main__":
+    main()
+
+# langchain-ocr image.png -o output.md

langchain_ocr_lib/prompt_templates/ocr_prompt.py

@@ -0,0 +1,60 @@
+import json
+
+from langchain.prompts import ChatPromptTemplate
+
+from langchain_ocr_lib.language_mapping.language_mapping import get_language_name_from_pycountry
+
+
+def ocr_prompt_template_builder(language: str = "en", model_name: str = "") -> str:
+    system_prompt = f"""
+    You are an advanced OCR tool. Your task is to extract all text content from this image in {get_language_name_from_pycountry(language)} **verbatim**, without any modifications, interpretations, summarizations, or omissions by keeping the original format in Markdown. **It is imperative that you do not add, infer, or hallucinate any content that is not explicitly present in the image.**
+
+    **Requirements:** Adhere to the following guidelines:
+
+    - **Headers:** Use Markdown headers (`#`, `##`, `###`, etc.) **only if corresponding heading structures are explicitly present in the image**. Match the level of the header accurately.
+    - **Lists:** Preserve all original list formats (unordered lists using `-` or `*`, and ordered lists with numbers) **exactly as they appear** in the image. Maintain the original indentation.
+    - **Text Formatting:** Retain all visual text formatting (bold, italics, underlines, strikethrough, etc.) using the appropriate Markdown syntax (`**bold**`, `*italic*`, `<u>underline</u>`, `~~strikethrough~~`). If a direct Markdown equivalent doesn't exist, prioritize accuracy of the text content.
+    - **Code Blocks:** If code or preformatted text is detected (often with a distinct font or background), format it using Markdown code blocks (using triple backticks ```).
+    - **Tables:** If tabular data is present, attempt to format it as a Markdown table using pipes `|` and hyphens `-`. If the table structure is complex, prioritize accurate text extraction over perfect table formatting.
+    - **Spacing and Line Breaks:** Maintain original line breaks and spacing to preserve the layout as accurately as possible.
+
+    **Additional Verification:**
+    - After extraction, verify that every Markdown element (headers, lists, code blocks, tables, etc.) exactly reflects the appearance and structure in the image.
+    - Ensure that no part of the content (including headers, footers, and any subtext) is omitted or altered.
+    - If any element is ambiguous, replicate the original formatting as closely as possible.
+
+    **Text Extraction:**
+    - Extract all text content from the image, including headings, paragraphs, lists, tables, and any other textual elements.
+    - Do **not omit** any part of the page.
+    - Accurately replicate all visual formatting such as bold, italics, underlines, and other styles.
+
+    **Example:**
+    If the image contains the following text layout:
+    ------------------------------------------------
+    # Chapter 1: Introduction
+
+    Welcome to the document.
+
+    **Key Points:**
+    - Item 1
+    - Item 2
+
+    ```python
+    print("Hello, world!")
+    ```
+    ------------------------------------------------
+    Then your output should be exactly as above, preserving the Markdown syntax for headers, bold text, lists, and code blocks.
+
+    """
+
+    if "llama3.2" in model_name:
+        system_prompt = "<|begin_of_text|><|start_header_id|>system<|end_header_id|>" + system_prompt + "<|eot_id|>"
+
+    ocr_prompt_template = [
+        {"role": "system", "content": system_prompt},
+        {
+            "role": "user",
+            "content": json.dumps([{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,{image_data}"}}]),
+        },
+    ]
+    return ocr_prompt_template

langchain_ocr_lib/tracers/traced_chain.py

@@ -0,0 +1,88 @@
+"""Module for the TracedGraph class."""
+
+import uuid
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from langchain_core.runnables import RunnableConfig, ensure_config
+
+from langchain_ocr_lib.chains.chain import Chain
+
+RunnableInput = Any
+RunnableOutput = Any
+
+
+class TracedChain(Chain[RunnableInput, RunnableOutput], ABC):
+    """A class to represent a traced graph in an asynchronous chain.
+
+    This class is designed to wrap around an inner Runnable chain and add tracing capabilities to it.
+    It provides methods to asynchronously invoke the chain with tracing and to manage session IDs and tracing callbacks.
+
+    Attributes
+    ----------
+    SESSION_ID_KEY : str
+        The key used to store the session ID in the metadata.
+    METADATA_KEY : str
+        The key used to store metadata.
+    """
+
+    SESSION_ID_KEY = "session_id"
+    METADATA_KEY = "metadata"
+
+    async def ainvoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Asynchronously invoke the chain with the given input and configuration.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        config : Optional[RunnableConfig], optional
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments.
+
+        Returns
+        -------
+        RunnableOutput
+            The output produced by the chain after processing the input.
+
+        """
+        config = ensure_config(config)
+        session_id = self._get_session_id(config)
+        config_with_tracing = self._add_tracing_callback(session_id, config)
+        return await self._inner_chain.ainvoke(chain_input, config=config_with_tracing)
+
+    def invoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Invoke the chain with the given input and configuration.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        config : Optional[RunnableConfig], optional
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments.
+
+        Returns
+        -------
+        RunnableOutput
+            The output produced by the chain after processing the input.
+        """
+        config = ensure_config(config)
+        session_id = self._get_session_id(config)
+        config_with_tracing = self._add_tracing_callback(session_id, config)
+        return self._inner_chain.invoke(chain_input, config=config_with_tracing)
+
+    @abstractmethod
+    def _add_tracing_callback(self, session_id: str, config: Optional[RunnableConfig]) -> RunnableConfig:
+        ...
+
+    def _get_session_id(self, config: Optional[RunnableConfig]) -> str:
+        return config.get(self.METADATA_KEY, {}).get(self.SESSION_ID_KEY, str(uuid.uuid4()))

langchain_ocr_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: langchain-ocr-lib
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: Andreas Klos
+Author-email: aklos@outlook.de
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: deprecated (>=1.2.14,<2.0.0)
+Requires-Dist: inject (>=5.2.1,<6.0.0)
+Requires-Dist: langchain-community (>=0.3.19,<0.4.0)
+Requires-Dist: langchain-ollama (>=0.2.0,<0.3.0)
+Requires-Dist: langchain-openai (>=0.3.8,<0.4.0)
+Requires-Dist: langfuse (>=2.59.7,<3.0.0)
+Requires-Dist: openai (>=1.42.0,<2.0.0)
+Requires-Dist: pdf2image (>=1.17.0,<2.0.0)
+Requires-Dist: pillow (>=11.0.0,<12.0.0)
+Requires-Dist: pycountry (>=24.6.1,<25.0.0)
+Requires-Dist: pytest-asyncio (>=0.25.0,<0.26.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Description-Content-Type: text/markdown
+
+

langchain_ocr_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+langchain_ocr_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/chains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/chains/chain.py,sha256=D00wnm987YgkJsIAIwQVehX_B4kBOzrjistaPf1M0GE,1946
+langchain_ocr_lib/converter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/converter/converter.py,sha256=aJuaLX2942d8WRPNaU0cUPO1_266QE7Y6SVKpnxpGBA,1196
+langchain_ocr_lib/di_config.py,sha256=H1CxtSlzUH3QGkRFBQqgMGJZx5HGWQ0yrB2kEvFIbOk,3083
+langchain_ocr_lib/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/chains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/chains/ocr_chain.py,sha256=eGiflXVbo1UP56rRHPY6fB4woJtyIvv4SmXNC1RHWFY,2594
+langchain_ocr_lib/impl/converter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/converter/image_converter.py,sha256=G1rDOCbudWNL4sDvSGJ7CeeFrWUblfWPGaZf5JsnpiM,2871
+langchain_ocr_lib/impl/converter/pdf_converter.py,sha256=ssj8DL_9wf6kMhjUhDkw0gwSwNLrvgh8nBRspwj60Vk,3510
+langchain_ocr_lib/impl/langfuse_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/langfuse_manager/langfuse_manager.py,sha256=G_qGE_-LnPpNJYgkoDoVqoXYkwsaMkB_HN2uSng3YVA,5245
+langchain_ocr_lib/impl/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/llms/llm_factory.py,sha256=9DsUdoYNrjeWLGA9ISDdHN2cxcQ7DquNQ5it6zSxHlg,2199
+langchain_ocr_lib/impl/llms/llm_type.py,sha256=_Ap7yStlBn0tyOyfVLH1c2j2A9-ccsTCxAm7bgoRQnM,268
+langchain_ocr_lib/impl/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/settings/langfuse_settings.py,sha256=5lr3tVeiHXDUaYtWAnZPXrKxBJgM2wgaz7yyZThhCsE,812
+langchain_ocr_lib/impl/settings/language_settings.py,sha256=tdAC1t5wGu1MoH1jhjkDnxnX4Ui7giwxt7Qm8_LPkP8,627
+langchain_ocr_lib/impl/settings/llm_class_type_settings.py,sha256=4KC6zxby13wn38rB8055J8LNVTsmUfrOiyLtLuToHaM,598
+langchain_ocr_lib/impl/settings/ollama_chat_settings.py,sha256=8RWMsaK4qDrqC6Mrxekr8IEDYwcvjYwhw9xDwZemxI4,1506
+langchain_ocr_lib/impl/settings/openai_chat_settings.py,sha256=cXzxe-sea8VCK2M_u9ZIL4l8AR_YdhmA-phZa9fwf8o,1233
+langchain_ocr_lib/impl/tracers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/impl/tracers/langfuse_traced_chain.py,sha256=lfYLEf9mJ2ie5wofHFG_FUicRi1281XGBC0GKXcAkHM,1546
+langchain_ocr_lib/language_mapping/language_mapping.py,sha256=VY7WkkZauoHNxkvgUYbig0rDmlKqDkz24cXMd6A7txM,700
+langchain_ocr_lib/main.py,sha256=_kx6pIsIV9pii2_TSYisFT4tKDQHMHef6buWhWoj11E,3485
+langchain_ocr_lib/prompt_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/prompt_templates/ocr_prompt.py,sha256=3Be1AL-HJkxPnAP0DNH1MqvAxFWTCeM5UOKP63xkHsY,3543
+langchain_ocr_lib/tracers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_ocr_lib/tracers/traced_chain.py,sha256=uxRkdLNn_G6dAsti_gUuF7muhIj10xrOUL7HUga40oc,3056
+langchain_ocr_lib-0.1.0.dist-info/METADATA,sha256=2H3iEatfiflH4GcrFhIw2Cg8wjsgKsLoeP2irFsVTio,991
+langchain_ocr_lib-0.1.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+langchain_ocr_lib-0.1.0.dist-info/entry_points.txt,sha256=l4mIs0tnIgbJYuVveZySQKVBnqNMHS-8ZZtLwz8ag5k,61
+langchain_ocr_lib-0.1.0.dist-info/RECORD,,

langchain_ocr_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.2
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_ocr_lib-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+langchain-ocr=langchain_ocr_lib.main:main
+