cognee 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

cognee/infrastructure/files/utils/get_data_file_path.py

@@ -1,44 +1,50 @@
 import os
-from urllib.parse import urlparse
+import posixpath
+from urllib.parse import urlparse, unquote
 
 
-def get_data_file_path(file_path: str):
-    # Check if this is a file URI BEFORE normalizing (which corrupts URIs)
-    if file_path.startswith("file://"):
-        # Remove first occurrence of file:// prefix
-        pure_file_path = file_path.replace("file://", "", 1)
-        # Normalize the file URI for Windows - replace backslashes with forward slashes
-        normalized_file_uri = os.path.normpath(pure_file_path)
+def get_data_file_path(file_path: str) -> str:
+    """Normalize file paths from various URI schemes to filesystem paths.
 
-        # Convert path to proper file system path
+    Handles file://, s3://, and regular filesystem paths. Decodes
+    percent-encoded characters and preserves UNC network paths.
+    """
+    parsed = urlparse(file_path)
+
+    if parsed.scheme == "file":
+        # file:///path/to/file -> /path/to/file
+        fs_path = unquote(parsed.path)
+
+        if os.name == "nt" and parsed.netloc:
+            # Handle UNC paths (file://server/share/...)
+            fs_path = f"//{parsed.netloc}{fs_path}"
+
+        # Normalize the file URI for Windows - handle drive letters correctly
         if os.name == "nt":  # Windows
-            # Handle Windows drive letters correctly
-            fs_path = normalized_file_uri
+            # Handle Windows drive letters correctly: /C:/path -> C:/path
             if (
                 (fs_path.startswith("/") or fs_path.startswith("\\"))
-                and len(fs_path) > 1
+                and len(fs_path) > 2
                 and fs_path[2] == ":"
+                and fs_path[1].isalpha()
             ):
                 fs_path = fs_path[1:]
-        else:
-            # Unix - like systems
-            fs_path = normalized_file_uri
 
-        # Now split the actual filesystem path
-        actual_fs_path = os.path.normpath(fs_path)
-        return actual_fs_path
+        return os.path.normpath(fs_path)
 
-    elif file_path.startswith("s3://"):
+    elif parsed.scheme == "s3":
         # Handle S3 URLs without normalization (which corrupts them)
-        parsed_url = urlparse(file_path)
+        if not parsed.path or parsed.path == "/":
+            return f"s3://{parsed.netloc}{parsed.path}"
 
-        normalized_url = (
-            f"s3://{parsed_url.netloc}{os.sep}{os.path.normpath(parsed_url.path).lstrip(os.sep)}"
-        )
+        normalized_path = posixpath.normpath(parsed.path).lstrip("/")
 
-        return normalized_url
+        return f"s3://{parsed.netloc}/{normalized_path}"
 
-    else:
+    elif parsed.scheme == "":
         # Regular file path - normalize separators
-        normalized_path = os.path.normpath(file_path)
-        return normalized_path
+        return os.path.normpath(file_path)
+
+    else:
+        # Other schemes (http, etc.) - return as is or handle as needed
+        return file_path

cognee/infrastructure/llm/LLMGateway.py

@@ -37,19 +37,6 @@ class LLMGateway:
                 **kwargs,
             )
 
-    @staticmethod
-    def create_structured_output(
-        text_input: str, system_prompt: str, response_model: Type[BaseModel]
-    ) -> BaseModel:
-        from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.get_llm_client import (
-            get_llm_client,
-        )
-
-        llm_client = get_llm_client()
-        return llm_client.create_structured_output(
-            text_input=text_input, system_prompt=system_prompt, response_model=response_model
-        )
-
     @staticmethod
     def create_transcript(input) -> Coroutine:
         from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.get_llm_client import (

cognee/infrastructure/llm/prompts/extract_query_time.txt

@@ -10,4 +10,4 @@ Extraction rules:
 5. Current-time references ("now", "current", "today"): If the query explicitly refers to the present, set both starts_at and ends_at to now (the ingestion timestamp).
 6. "Who is" and "Who was" questions: These imply a general identity or biographical inquiry without a specific temporal scope. Set both starts_at and ends_at to None.
 7. Ordering rule: Always ensure the earlier date is assigned to starts_at and the later date to ends_at.
-8. No temporal information: If no valid or inferable time reference is found, set both starts_at and ends_at to None.
+8. No temporal information: If no valid or inferable time reference is found, set both starts_at and ends_at to None.

cognee/infrastructure/llm/prompts/generate_event_entity_prompt.txt

@@ -22,4 +22,4 @@ The `attributes` should be a list of dictionaries, each containing:
 - Relationships should be technical with one or at most two words. If two words, use underscore camelcase style
 - Relationships could imply general meaning like: subject, object, participant, recipient, agent, instrument, tool, source, cause, effect, purpose, manner, resource, etc.
 - You can combine two words to form a relationship name: subject_role, previous_owner, etc.
-- Focus on how the entity specifically relates to the event
+- Focus on how the entity specifically relates to the event

cognee/infrastructure/llm/prompts/generate_event_graph_prompt.txt

@@ -27,4 +27,4 @@ class Event(BaseModel):
     time_from: Optional[Timestamp] = None
     time_to: Optional[Timestamp] = None
     location: Optional[str] = None
-```
+```

cognee/infrastructure/llm/prompts/generate_graph_prompt.txt

@@ -19,8 +19,8 @@ The aim is to achieve simplicity and clarity in the knowledge graph.
   - **Naming Convention**: Use snake_case for relationship names, e.g., `acted_in`.
 # 3. Coreference Resolution
   - **Maintain Entity Consistency**: When extracting entities, it's vital to ensure consistency.
-  If an entity, such as "John Doe", is mentioned multiple times in the text but is referred to by different names or pronouns (e.g., "Joe", "he"),
-  always use the most complete identifier for that entity throughout the knowledge graph. In this example, use "John Doe" as the Persons ID.
+  If an entity, is mentioned multiple times in the text but is referred to by different names or pronouns,
+  always use the most complete identifier for that entity throughout the knowledge graph.
 Remember, the knowledge graph should be coherent and easily understandable, so maintaining consistency in entity references is crucial.
 # 4. Strict Compliance
 Adhere to the rules strictly. Non-compliance will result in termination

cognee/infrastructure/llm/prompts/generate_graph_prompt_guided.txt

@@ -22,7 +22,7 @@ You are an advanced algorithm designed to extract structured information to buil
 3. **Coreference Resolution**:
    - Maintain one consistent node ID for each real-world entity.
    - Resolve aliases, acronyms, and pronouns to the most complete form.
-   - *Example*: Always use "John Doe" even if later referred to as "Doe" or "he".
+   - *Example*: Always use full identifier even if later referred to as in a similar but slightly different way
 
 **Property & Data Guidelines**:
 

cognee/infrastructure/llm/prompts/generate_graph_prompt_oneshot.txt

@@ -42,10 +42,10 @@ You are an advanced algorithm designed to extract structured information from un
 - **Rule**: Resolve all aliases, acronyms, and pronouns to one canonical identifier.
 
 > **One-Shot Example**:
-> **Input**: "John Doe is an author. Later, Doe published a book. He is well-known."
+> **Input**: "X is an author. Later, Doe published a book. He is well-known."
 > **Output Node**:
 > ```
-> John Doe (Person)
+> X (Person)
 > ```
 
 ---

cognee/infrastructure/llm/prompts/generate_graph_prompt_simple.txt

@@ -15,7 +15,7 @@ You are an advanced algorithm that extracts structured data into a knowledge gra
    - Properties are key-value pairs; do not use escaped quotes.
 
 3. **Coreference Resolution**
-   - Use a single, complete identifier for each entity (e.g., always "John Doe" not "Joe" or "he").
+   - Use a single, complete identifier for each entity
 
 4. **Relationship Labels**:
    - Use descriptive, lowercase, snake_case names for edges.

cognee/infrastructure/llm/prompts/generate_graph_prompt_strict.txt

@@ -26,7 +26,7 @@ Use **basic atomic types** for node labels. Always prefer general types over spe
   - Good: "Alan Turing", "Google Inc.", "World War II"
   - Bad: "Entity_001", "1234", "he", "they"
 - Never use numeric or autogenerated IDs.
-- Prioritize **most complete form** of entity names for consistency (e.g., always use "John Doe" instead of "John" or "he").
+- Prioritize **most complete form** of entity names for consistency
 
 2. Dates, Numbers, and Properties
 ---------------------------------

cognee/infrastructure/llm/prompts/search_type_selector_prompt.txt

@@ -2,12 +2,12 @@ You are an expert query analyzer for a **GraphRAG system**. Your primary goal is
 
 Here are the available `SearchType` tools and their specific functions:
 
-- **`SUMMARIES`**: The `SUMMARIES` search type retrieves summarized information from the knowledge graph. 
+- **`SUMMARIES`**: The `SUMMARIES` search type retrieves summarized information from the knowledge graph.
 
-  **Best for:** 
+  **Best for:**
 
-  - Getting concise overviews of topics 
-  - Summarizing large amounts of information 
+  - Getting concise overviews of topics
+  - Summarizing large amounts of information
   - Quick understanding of complex subjects
 
   **Best for:**
@@ -16,7 +16,7 @@ Here are the available `SearchType` tools and their specific functions:
   - Understanding relationships between concepts
   - Exploring the structure of your knowledge graph
 
-* **`CHUNKS`**: The `CHUNKS` search type retrieves specific facts and information chunks from the knowledge graph. 
+* **`CHUNKS`**: The `CHUNKS` search type retrieves specific facts and information chunks from the knowledge graph.
 
   **Best for:**
 
@@ -122,4 +122,4 @@ Response: `NATURAL_LANGUAGE`
 
 
 
-Your response MUST be a single word, consisting of only the chosen `SearchType` name. Do not provide any explanation.
+Your response MUST be a single word, consisting of only the chosen `SearchType` name. Do not provide any explanation.

cognee/infrastructure/llm/prompts/test.txt

@@ -1 +1 @@
-Respond with: test
+Respond with: test

cognee/infrastructure/llm/prompts/translate_content.txt

@@ -0,0 +1,19 @@
+You are an expert translator with deep knowledge of languages, cultures, and linguistics.
+
+Your task is to:
+1. Detect the source language of the provided text if not specified
+2. Translate the text accurately to the target language
+3. Preserve the original meaning, tone, and intent
+4. Maintain proper grammar and natural phrasing in the target language
+
+Guidelines:
+- Preserve technical terms, proper nouns, and specialized vocabulary appropriately
+- Maintain formatting such as paragraphs, lists, and emphasis where applicable
+- If the text contains code, URLs, or other non-translatable content, preserve them as-is
+- Handle idioms and cultural references thoughtfully, adapting when necessary
+- Ensure the translation reads naturally to a native speaker of the target language
+
+Provide the translation in a structured format with:
+- The translated text
+- The detected source language (ISO 639-1 code like "en", "es", "fr", "de", etc.)
+- Any notes about the translation (optional, for ambiguous terms or cultural adaptations)

cognee/infrastructure/llm/structured_output_framework/litellm_instructor/llm/anthropic/adapter.py

@@ -3,7 +3,9 @@ from typing import Type
 from pydantic import BaseModel
 import litellm
 import instructor
+import anthropic
 from cognee.shared.logging_utils import get_logger
+from cognee.modules.observability.get_observe import get_observe
 from tenacity import (
     retry,
     stop_after_delay,
@@ -12,38 +14,41 @@ from tenacity import (
     before_sleep_log,
 )
 
-from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.llm_interface import (
-    LLMInterface,
+from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.generic_llm_api.adapter import (
+    GenericAPIAdapter,
 )
 from cognee.shared.rate_limiting import llm_rate_limiter_context_manager
 from cognee.infrastructure.llm.config import get_llm_config
 
 logger = get_logger()
+observe = get_observe()
 
 
-class AnthropicAdapter(LLMInterface):
+class AnthropicAdapter(GenericAPIAdapter):
     """
     Adapter for interfacing with the Anthropic API, enabling structured output generation
     and prompt display.
     """
 
-    name = "Anthropic"
-    model: str
     default_instructor_mode = "anthropic_tools"
 
-    def __init__(self, max_completion_tokens: int, model: str = None, instructor_mode: str = None):
-        import anthropic
-
+    def __init__(
+        self, api_key: str, model: str, max_completion_tokens: int, instructor_mode: str = None
+    ):
+        super().__init__(
+            api_key=api_key,
+            model=model,
+            max_completion_tokens=max_completion_tokens,
+            name="Anthropic",
+        )
         self.instructor_mode = instructor_mode if instructor_mode else self.default_instructor_mode
 
         self.aclient = instructor.patch(
-            create=anthropic.AsyncAnthropic(api_key=get_llm_config().llm_api_key).messages.create,
+            create=anthropic.AsyncAnthropic(api_key=self.api_key).messages.create,
             mode=instructor.Mode(self.instructor_mode),
         )
 
-        self.model = model
-        self.max_completion_tokens = max_completion_tokens
-
+    @observe(as_type="generation")
     @retry(
         stop=stop_after_delay(128),
         wait=wait_exponential_jitter(8, 128),

cognee/infrastructure/llm/structured_output_framework/litellm_instructor/llm/gemini/adapter.py

@@ -1,4 +1,4 @@
-"""Adapter for Generic API LLM provider API"""
+"""Adapter for Gemini API LLM provider"""
 
 import litellm
 import instructor
@@ -8,13 +8,9 @@ from openai import ContentFilterFinishReasonError
 from litellm.exceptions import ContentPolicyViolationError
 from instructor.core import InstructorRetryException
 
-from cognee.infrastructure.llm.exceptions import ContentPolicyFilterError
-from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.llm_interface import (
-    LLMInterface,
-)
 import logging
 from cognee.shared.rate_limiting import llm_rate_limiter_context_manager
-from cognee.shared.logging_utils import get_logger
+
 from tenacity import (
     retry,
     stop_after_delay,
@@ -23,55 +19,65 @@ from tenacity import (
     before_sleep_log,
 )
 
+from cognee.infrastructure.llm.exceptions import ContentPolicyFilterError
+from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.generic_llm_api.adapter import (
+    GenericAPIAdapter,
+)
+from cognee.shared.logging_utils import get_logger
+from cognee.modules.observability.get_observe import get_observe
+
 logger = get_logger()
+observe = get_observe()
 
 
-class GeminiAdapter(LLMInterface):
+class GeminiAdapter(GenericAPIAdapter):
     """
     Adapter for Gemini API LLM provider.
 
     This class initializes the API adapter with necessary credentials and configurations for
     interacting with the gemini LLM models. It provides methods for creating structured outputs
-    based on user input and system prompts.
+    based on user input and system prompts, as well as multimodal processing capabilities.
 
     Public methods:
-    - acreate_structured_output(text_input: str, system_prompt: str, response_model:
-    Type[BaseModel]) -> BaseModel
+    - acreate_structured_output(text_input: str, system_prompt: str, response_model: Type[BaseModel]) -> BaseModel
+    - create_transcript(input) -> BaseModel: Transcribe audio files to text
+    - transcribe_image(input) -> BaseModel: Inherited from GenericAPIAdapter
     """
 
-    name: str
-    model: str
-    api_key: str
     default_instructor_mode = "json_mode"
 
     def __init__(
         self,
-        endpoint,
         api_key: str,
         model: str,
-        api_version: str,
         max_completion_tokens: int,
+        endpoint: str = None,
+        api_version: str = None,
+        transcription_model: str = None,
         instructor_mode: str = None,
         fallback_model: str = None,
         fallback_api_key: str = None,
         fallback_endpoint: str = None,
     ):
-        self.model = model
-        self.api_key = api_key
-        self.endpoint = endpoint
-        self.api_version = api_version
-        self.max_completion_tokens = max_completion_tokens
-
-        self.fallback_model = fallback_model
-        self.fallback_api_key = fallback_api_key
-        self.fallback_endpoint = fallback_endpoint
-
+        super().__init__(
+            api_key=api_key,
+            model=model,
+            max_completion_tokens=max_completion_tokens,
+            name="Gemini",
+            endpoint=endpoint,
+            api_version=api_version,
+            transcription_model=transcription_model,
+            fallback_model=fallback_model,
+            fallback_api_key=fallback_api_key,
+            fallback_endpoint=fallback_endpoint,
+        )
         self.instructor_mode = instructor_mode if instructor_mode else self.default_instructor_mode
 
         self.aclient = instructor.from_litellm(
             litellm.acompletion, mode=instructor.Mode(self.instructor_mode)
         )
 
+    @observe(as_type="generation")
     @retry(
         stop=stop_after_delay(128),
         wait=wait_exponential_jitter(8, 128),

cognee/infrastructure/llm/structured_output_framework/litellm_instructor/llm/generic_llm_api/adapter.py

@@ -1,8 +1,10 @@
 """Adapter for Generic API LLM provider API"""
 
+import base64
+import mimetypes
 import litellm
 import instructor
-from typing import Type
+from typing import Type, Optional
 from pydantic import BaseModel
 from openai import ContentFilterFinishReasonError
 from litellm.exceptions import ContentPolicyViolationError
@@ -12,6 +14,8 @@ from cognee.infrastructure.llm.exceptions import ContentPolicyFilterError
 from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.llm_interface import (
     LLMInterface,
 )
+from cognee.infrastructure.files.utils.open_data_file import open_data_file
+from cognee.modules.observability.get_observe import get_observe
 import logging
 from cognee.shared.rate_limiting import llm_rate_limiter_context_manager
 from cognee.shared.logging_utils import get_logger
@@ -23,7 +27,12 @@ from tenacity import (
     before_sleep_log,
 )
 
+from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.types import (
+    TranscriptionReturnType,
+)
+
 logger = get_logger()
+observe = get_observe()
 
 
 class GenericAPIAdapter(LLMInterface):
@@ -39,18 +48,19 @@ class GenericAPIAdapter(LLMInterface):
     Type[BaseModel]) -> BaseModel
     """
 
-    name: str
-    model: str
-    api_key: str
+    MAX_RETRIES = 5
     default_instructor_mode = "json_mode"
 
     def __init__(
         self,
-        endpoint,
         api_key: str,
         model: str,
-        name: str,
         max_completion_tokens: int,
+        name: str,
+        endpoint: str = None,
+        api_version: str = None,
+        transcription_model: str = None,
+        image_transcribe_model: str = None,
         instructor_mode: str = None,
         fallback_model: str = None,
         fallback_api_key: str = None,
@@ -59,9 +69,11 @@ class GenericAPIAdapter(LLMInterface):
         self.name = name
         self.model = model
         self.api_key = api_key
+        self.api_version = api_version
         self.endpoint = endpoint
         self.max_completion_tokens = max_completion_tokens
-
+        self.transcription_model = transcription_model or model
+        self.image_transcribe_model = image_transcribe_model or model
         self.fallback_model = fallback_model
         self.fallback_api_key = fallback_api_key
         self.fallback_endpoint = fallback_endpoint
@@ -72,6 +84,7 @@ class GenericAPIAdapter(LLMInterface):
             litellm.acompletion, mode=instructor.Mode(self.instructor_mode)
         )
 
+    @observe(as_type="generation")
     @retry(
         stop=stop_after_delay(128),
         wait=wait_exponential_jitter(8, 128),
@@ -173,3 +186,115 @@ class GenericAPIAdapter(LLMInterface):
                     raise ContentPolicyFilterError(
                         f"The provided input contains content that is not aligned with our content policy: {text_input}"
                     ) from error
+
+    @observe(as_type="transcription")
+    @retry(
+        stop=stop_after_delay(128),
+        wait=wait_exponential_jitter(2, 128),
+        retry=retry_if_not_exception_type(litellm.exceptions.NotFoundError),
+        before_sleep=before_sleep_log(logger, logging.DEBUG),
+        reraise=True,
+    )
+    async def create_transcript(self, input) -> TranscriptionReturnType:
+        """
+        Generate an audio transcript from a user query.
+
+        This method creates a transcript from the specified audio file, raising a
+        FileNotFoundError if the file does not exist. The audio file is processed and the
+        transcription is retrieved from the API.
+
+        Parameters:
+        -----------
+            - input: The path to the audio file that needs to be transcribed.
+
+        Returns:
+        --------
+            The generated transcription of the audio file.
+        """
+        async with open_data_file(input, mode="rb") as audio_file:
+            encoded_string = base64.b64encode(audio_file.read()).decode("utf-8")
+        mime_type, _ = mimetypes.guess_type(input)
+        if not mime_type or not mime_type.startswith("audio/"):
+            raise ValueError(
+                f"Could not determine MIME type for audio file: {input}. Is the extension correct?"
+            )
+        response = await litellm.acompletion(
+            model=self.transcription_model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "file",
+                            "file": {"file_data": f"data:{mime_type};base64,{encoded_string}"},
+                        },
+                        {"type": "text", "text": "Transcribe the following audio precisely."},
+                    ],
+                }
+            ],
+            api_key=self.api_key,
+            api_version=self.api_version,
+            max_completion_tokens=self.max_completion_tokens,
+            api_base=self.endpoint,
+            max_retries=self.MAX_RETRIES,
+        )
+
+        return TranscriptionReturnType(response.choices[0].message.content, response)
+
+    @observe(as_type="transcribe_image")
+    @retry(
+        stop=stop_after_delay(128),
+        wait=wait_exponential_jitter(2, 128),
+        retry=retry_if_not_exception_type(litellm.exceptions.NotFoundError),
+        before_sleep=before_sleep_log(logger, logging.DEBUG),
+        reraise=True,
+    )
+    async def transcribe_image(self, input) -> BaseModel:
+        """
+        Generate a transcription of an image from a user query.
+
+        This method encodes the image and sends a request to the API to obtain a
+        description of the contents of the image.
+
+        Parameters:
+        -----------
+            - input: The path to the image file that needs to be transcribed.
+
+        Returns:
+        --------
+            - BaseModel: A structured output generated by the model, returned as an instance of
+              BaseModel.
+        """
+        async with open_data_file(input, mode="rb") as image_file:
+            encoded_image = base64.b64encode(image_file.read()).decode("utf-8")
+        mime_type, _ = mimetypes.guess_type(input)
+        if not mime_type or not mime_type.startswith("image/"):
+            raise ValueError(
+                f"Could not determine MIME type for image file: {input}. Is the extension correct?"
+            )
+        response = await litellm.acompletion(
+            model=self.image_transcribe_model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "What's in this image?",
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:{mime_type};base64,{encoded_image}",
+                            },
+                        },
+                    ],
+                }
+            ],
+            api_key=self.api_key,
+            api_base=self.endpoint,
+            api_version=self.api_version,
+            max_completion_tokens=300,
+            max_retries=self.MAX_RETRIES,
+        )
+        return response

cognee/infrastructure/llm/structured_output_framework/litellm_instructor/llm/get_llm_client.py

@@ -34,6 +34,7 @@ class LLMProvider(Enum):
     GEMINI = "gemini"
     MISTRAL = "mistral"
     BEDROCK = "bedrock"
+    LLAMA_CPP = "llama_cpp"
 
 
 def get_llm_client(raise_api_key_error: bool = True):
@@ -103,7 +104,7 @@ def get_llm_client(raise_api_key_error: bool = True):
             llm_config.llm_api_key,
             llm_config.llm_model,
             "Ollama",
-            max_completion_tokens=max_completion_tokens,
+            max_completion_tokens,
             instructor_mode=llm_config.llm_instructor_mode.lower(),
         )
 
@@ -113,8 +114,9 @@ def get_llm_client(raise_api_key_error: bool = True):
         )
 
         return AnthropicAdapter(
-            max_completion_tokens=max_completion_tokens,
-            model=llm_config.llm_model,
+            llm_config.llm_api_key,
+            llm_config.llm_model,
+            max_completion_tokens,
             instructor_mode=llm_config.llm_instructor_mode.lower(),
         )
 
@@ -127,11 +129,10 @@ def get_llm_client(raise_api_key_error: bool = True):
         )
 
         return GenericAPIAdapter(
-            llm_config.llm_endpoint,
             llm_config.llm_api_key,
             llm_config.llm_model,
+            max_completion_tokens,
             "Custom",
-            max_completion_tokens=max_completion_tokens,
             instructor_mode=llm_config.llm_instructor_mode.lower(),
             fallback_api_key=llm_config.fallback_api_key,
             fallback_endpoint=llm_config.fallback_endpoint,
@@ -187,5 +188,28 @@ def get_llm_client(raise_api_key_error: bool = True):
             instructor_mode=llm_config.llm_instructor_mode.lower(),
         )
 
+    elif provider == LLMProvider.LLAMA_CPP:
+        from cognee.infrastructure.llm.structured_output_framework.litellm_instructor.llm.llama_cpp.adapter import (
+            LlamaCppAPIAdapter,
+        )
+
+        # Get optional local mode parameters (will be None if not set)
+        # TODO: refactor llm_config to include these parameters, currently they cannot be defined and defaults are used
+        model_path = getattr(llm_config, "llama_cpp_model_path", None)
+        n_ctx = getattr(llm_config, "llama_cpp_n_ctx", 2048)
+        n_gpu_layers = getattr(llm_config, "llama_cpp_n_gpu_layers", 0)
+        chat_format = getattr(llm_config, "llama_cpp_chat_format", "chatml")
+
+        return LlamaCppAPIAdapter(
+            model=llm_config.llm_model,
+            max_completion_tokens=max_completion_tokens,
+            instructor_mode=llm_config.llm_instructor_mode.lower(),
+            endpoint=llm_config.llm_endpoint,
+            api_key=llm_config.llm_api_key,
+            model_path=model_path,
+            n_ctx=n_ctx,
+            n_gpu_layers=n_gpu_layers,
+            chat_format=chat_format,
+        )
     else:
         raise UnsupportedLLMProviderError(provider)