Repository: run-llama/llama_index

Issue:
[Bug]: BadRequestError - Invalid MIME Type: "Only image types are supported" When Using Multimodal Query Engine
### Bug Description

I tried to run the [notebook](https://github.com/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_contextual_retrieval_rag.ipynb) available on Llama Index documentation on Contextual Retrieval. However, I encountered a `BadRequestError` with the message `Invalid MIME type. Only image types are supported` when running the Multimodal Query Engine script found on the Llama Index website. 

The error occurs when I try to execute a query. It seems related to how the `ImageNode` or `image_documents` are being handled, possibly due to incorrect file handling or MIME type validation.

---

### Error Traceback:

```python
BadRequestError: Error code: 400 - {'error': {'message': 'Invalid MIME type. Only image types are supported.', 'type': 'invalid_request_error', 'param': None, 'code': 'invalid_image_format'}}
```

Complete traceback:
```
Traceback (most recent call last):
File "my_script.py", line X, in <module>
    response = query_engine.query("which departments/teams use genAI the most and how are they using it?")
...
BadRequestError: Error code: 400 - {'error': {'message': 'Invalid MIME type. Only image types are supported.', 'type': 'invalid_request_error', 'param': None, 'code': 'invalid_image_format'}}
```

Llama Index Version: 0.12.10

### Steps to Reproduce:

1. Download and open the [script](https://github.com/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_contextual_retrieval_rag.ipynb) in your editor.
2. Add API Keys for the required services.
3. Run the script until the query: `"which departments/teams use genAI the most and how are they using it?"`

### Relevant Code:

Here is the script I used:

```python
from llama_index.core.query_engine import CustomQueryEngine, SimpleMultiModalQueryEngine
from llama_index.core.retrievers import BaseRetriever
from llama_index.multi_modal_llms.openai import OpenAIMultiModal
from llama_index.core.schema import ImageNode, NodeWithScore, MetadataMode
from llama_index.core.prompts import PromptTemplate
from llama_index.core.base.response.schema import Response
from typing import Optional
from config import OPENAI_API_KEY_PROD

os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY_PROD
gpt_4o = OpenAIMultiModal(model="gpt-4o", max_new_tokens=4096)

QA_PROMPT_TMPL = """\
Below we give parsed text from slides in two different formats, as well as the image.

---------------------
{context_str}
---------------------
Given the context information and not prior knowledge, answer the query. Explain whether you got the answer
from the parsed markdown or raw text or image, and if there's discrepancies, and your reasoning for the final answer.

Query: {query_str}
Answer: """

QA_PROMPT = PromptTemplate(QA_PROMPT_TMPL)


class MultimodalQueryEngine(CustomQueryEngine):
    """Custom multimodal Query Engine."""
    qa_prompt: PromptTemplate
    retriever: BaseRetriever
    multi_modal_llm: OpenAIMultiModal

    def __init__(self, qa_prompt: Optional[PromptTemplate] = None, **kwargs) -> None:
        super().__init__(qa_prompt=qa_prompt or QA_PROMPT, **kwargs)

    def custom_query(self, query_str: str):
        nodes = self.retriever.retrieve(query_str)
        image_nodes = [
            NodeWithScore(node=ImageNode(image_path=n.metadata["image_path"]))
            for n in nodes
        ]
        context_str = "\n\n".join(
            [r.get_content(metadata_mode=MetadataMode.LLM) for r in nodes]
        )
        fmt_prompt = self.qa_prompt.format(context_str=context_str, query_str=query_str)

        llm_response = self.multi_modal_llm.complete(
            prompt=fmt_prompt,
            image_documents=[image_node.node for image_node in image_nodes],
        )
        return Response(
            response=str(llm_response),
            source_nodes=nodes,
            metadata={"text_nodes": nodes, "image_nodes": image_nodes},
        )


query_engine = MultimodalQueryEngine(
    retriever=index.as_retriever(similarity_top_k=3), multi_modal_llm=gpt_4o
)

response = query_engine.query("which departments/teams use genAI the most and how are they using it?")
print(str(response))
```

### Relevant Logs/Tracbacks

_No response_

Discussion:
@dosubot: <!-- Answer -->
To resolve the `BadRequestError` with the message "Invalid MIME type. Only image types are supported," ensure that the MIME type of the image you are using is correctly identified and supported. The supported MIME types are `image/jpeg`, `image/png`, `image/gif`, and `image/webp`.

Here are some steps to check and correct the issue:

1. **File Extension Mapping**: Verify that the file extension of your image is correctly mapped to a supported MIME type. For example, if your image is a JPEG, the file extension should be `.jpg` or `.jpeg`.

2. **Base64 Image Handling**: If you are using a base64 encoded image, ensure that the function responsible for inferring the MIME type from base64 data correctly identifies it. The function should use a library like `filetype` to guess the MIME type from the decoded data.

3. **Image Document Setup**: When creating an `ImageNode`, ensure that the `image_path` in the metadata is correctly set and points to a valid image file. If using a base64 string directly, ensure it is a valid image encoding.

Here's a snippet to ensure the MIME type is correctly set:

```python
def generate_anthropic_multi_modal_chat_message(
    prompt: str,
    role: str,
    image_documents: Optional[Sequence[ImageDocument]] = None,
) -> List[Dict[str, Any]]:
    if image_documents is None:
        return [{"role": role, "content": prompt}]
    completion_content = []
    for image_document in image_documents:
        image_content: Dict[str, Any] = {}
        if image_document.image_path and image_document.image_path != "":
            mimetype = infer_image_mimetype_from_file_path(image_document.image_path)
            if mimetype not in ["image/jpeg", "image/png", "image/gif", "image/webp"]:
                raise ValueError("Unsupported MIME type")
            base64_image = encode_image(image_document.image_path)
            image_content = {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": mimetype,
                    "data": base64_image,
                },
            }
        completion_content.append(image_content)
    return [{"role": role, "content": completion_content}]
```

Ensure that the MIME type is one of the supported types before proceeding with the request. If the MIME type is not supported, handle the error accordingly <sup>[[1]](https://github.com/run-llama/llama_index/blob/main/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-anthropic/llama_index/multi_modal_llms/anthropic/utils.py)</sup>.


<!-- Dosu Comment Footer -->
*To continue talking to [Dosu](https://dosu.dev), mention @dosu.*

---
<sup>Help Dosu learn! Give it feedback: [Great Response](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=great_response) | [Irrelevant Answer](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=irrelevant_answer) | [Incorrect Sources](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=incorrect_sources) | [Too Verbose](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=too_verbose) | [Hallucination](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=hallucination) | [Other](https://app.dosu.dev/response-feedback/d60e51ab-b3bf-4e6b-ba61-2522658b0fff?feedback_type=other)</sup>
@masci: I tried your example locally on the branch from #17509 and it completes without errors, @gbaglini if you have the chance to double check it also works for you we can close this.@dosubot: Hi, @gbaglini. I'm [Dosu](https://dosu.dev), and I'm helping the LlamaIndex team manage their backlog and am marking this issue as stale.

**Issue Summary:**
- You reported a `BadRequestError` due to an "Invalid MIME type" when using the Multimodal Query Engine script.
- I suggested steps to ensure the MIME type of images is correctly identified, including verifying file extensions and handling base64 encoded images.
- @masci tested the example locally and reported no errors, suggesting the issue might be resolved.

**Next Steps:**
- Please confirm if this issue is still relevant with the latest version of the LlamaIndex repository. If it is, you can keep the discussion open by commenting here.
- If there is no further activity, this issue will be automatically closed in 7 days.

Thank you for your understanding and contribution!

Solution patch:
diff --git a/docs/docs/examples/finetuning/embeddings/finetune_embedding.ipynb b/docs/docs/examples/finetuning/embeddings/finetune_embedding.ipynb
index 00398d2c6..0d084c4e4 100644
--- a/docs/docs/examples/finetuning/embeddings/finetune_embedding.ipynb
+++ b/docs/docs/examples/finetuning/embeddings/finetune_embedding.ipynb
@@ -43,7 +43,8 @@
    "source": [
     "%pip install llama-index-llms-openai\n",
     "%pip install llama-index-embeddings-openai\n",
-    "%pip install llama-index-finetuning"
+    "%pip install llama-index-finetuning\n",
+    "%pip install llama-index-readers-file"
    ]
   },
   {
diff --git a/docs/docs/examples/graph_rag/llama_index_cognee_integration.ipynb b/docs/docs/examples/graph_rag/llama_index_cognee_integration.ipynb
new file mode 100644
index 000000000..5080c63ec
--- /dev/null
+++ b/docs/docs/examples/graph_rag/llama_index_cognee_integration.ipynb
@@ -0,0 +1,287 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1EpokQ8Y_5jIJ7HdixZms81Oqgh2sp7-E?usp=sharing)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LlamaIndex Cognee GraphRAG Integration\n",
+    "\n",
+    "Connecting external knowledge to the LLM efficiently and retrieving it  is a key challenge faced by developers. For developers and data scientists, integrating structured and unstructured data into AI workflows often involves multiple tools, complex pipelines, and time-consuming processes.\n",
+    "\n",
+    "Enter **cognee,** a powerful framework for knowledge and memory management, and LlamaIndex, a versatile data integration library. Together, they enable us to transform  retrieval-augmented generation (RAG) pipelines, into GraphRAG pipelines, streamlining the path from raw data to actionable insights.\n",
+    "\n",
+    "In this post, we’ll explore a demo that leverages cognee and LlamaIndex to create a knowledge graph from a LlamaIndex document, process it into a meaningful structure, and extract useful insights. By the end, you’ll see how these tools can give you new insights into your data by connecting various data sources in one big semantic layer you can analyze.\n",
+    "\n",
+    "## RAG - Recap\n",
+    "\n",
+    "RAG enhances LLMs by integrating external knowledge sources during inference. It does so by turning the data into a vector representation and storing it in a vector store.\n",
+    "\n",
+    "### Key Benefits of RAG:\n",
+    "\n",
+    "1. Connecting domain specific data to LLMs\n",
+    "2. Cost savings\n",
+    "3. Higher accuracy than base LLM\n",
+    "\n",
+    "However, building a RAG system presents challenges: handling diverse data formats, data updates, creating a robust metadata layer, and mediocre accuracy\n",
+    "\n",
+    "## Introducing cognee and LlamaIndex more\n",
+    "\n",
+    "cognee simplifies knowledge and memory management for LLMs, while LlamaIndex facilitates connecting LLMs to structured data sources and enabling agentic  use-cases\n",
+    "\n",
+    "cognee is inspired by human mind and higer cognitive functions. It mimics ways we construct our mental map of the world and build a semantic understanding of various objects, terms and issues in our everyday lives.\n",
+    "\n",
+    "cognee brings this approach to code by allowing developers to create  semantic layers that would allow users to store their ontologies which are **a formalised depiction of knowledge** in graphs.\n",
+    "\n",
+    "This lets you use the knowledge you have about a system connect it to LLMs in a modular way, with best data engineering practices, wide choice of vector and graph stores and various LLMs you can use.\n",
+    "\n",
+    "Together, they:\n",
+    "\n",
+    "- Turn unstructured and semi-structured data into a graph/vector representation.\n",
+    "- Enable ontology generation for particular domains, making unique graphs for every vertical\n",
+    "- Provide a deterministic layer for LLM outputs, ensuring consistency and reliability.\n",
+    "\n",
+    "## Step-by-Step Demo: Building a RAG System with Cognee and LlamaIndex\n",
+    "\n",
+    "### 1. Setting Up the Environment\n",
+    "\n",
+    "Start by importing the required libraries and defining the environment:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install llama-index-graph-rag-cognee==0.1.2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import asyncio\n",
+    "from llama_index.core import Document\n",
+    "from llama_index.graph_rag.cognee import CogneeGraphRAG\n",
+    "\n",
+    "if \"OPENAI_API_KEY\" not in os.environ:\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = \"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ensure you’ve set up your API keys and installed necessary dependencies.\n",
+    "\n",
+    "### 2. Preparing the Dataset\n",
+    "\n",
+    "We’ll use a brief profile of an individual as our sample dataset:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "documents = [\n",
+    "    Document(\n",
+    "        text=\"Jessica Miller, Experienced Sales Manager with a strong track record in driving sales growth and building high-performing teams.\"\n",
+    "    ),\n",
+    "    Document(\n",
+    "        text=\"David Thompson, Creative Graphic Designer with over 8 years of experience in visual design and branding.\"\n",
+    "    ),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Initializing CogneeGraphRAG\n",
+    "\n",
+    "Instantiate the Cognee framework with configurations for LLM, graph, and database providers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cogneeRAG = CogneeGraphRAG(\n",
+    "    llm_api_key=os.environ[\"OPENAI_API_KEY\"],\n",
+    "    llm_provider=\"openai\",\n",
+    "    llm_model=\"gpt-4o-mini\",\n",
+    "    graph_db_provider=\"networkx\",\n",
+    "    vector_db_provider=\"lancedb\",\n",
+    "    relational_db_provider=\"sqlite\",\n",
+    "    relational_db_name=\"cognee_db\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. Adding Data to Cognee\n",
+    "\n",
+    "Load the dataset into the cognee framework:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "await cogneeRAG.add(documents, \"test\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This step prepares the data for graph-based processing.\n",
+    "\n",
+    "### 5. Processing Data into a Knowledge Graph\n",
+    "\n",
+    "Transform the data into a structured knowledge graph:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "await cogneeRAG.process_data(\"test\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The graph now contains nodes and relationships derived from the dataset, creating a powerful structure for exploration.\n",
+    "\n",
+    "### 6. Performing Searches\n",
+    "\n",
+    "### Answer prompt based on knowledge graph approach:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search_results = await cogneeRAG.search(\n",
+    "    \"Tell me who are the people mentioned?\"\n",
+    ")\n",
+    "\n",
+    "print(\"\\n\\nAnswer based on knowledge graph:\\n\")\n",
+    "for result in search_results:\n",
+    "    print(f\"{result}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Answer prompt based on RAG approach:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search_results = await cogneeRAG.rag_search(\n",
+    "    \"Tell me who are the people mentioned?\"\n",
+    ")\n",
+    "\n",
+    "print(\"\\n\\nAnswer based on RAG:\\n\")\n",
+    "for result in search_results:\n",
+    "    print(f\"{result}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In conclusion, the results demonstrate a significant advantage of the knowledge graph-based approach (Graphrag) over the RAG approach. Graphrag successfully identified all the mentioned individuals across multiple documents, showcasing its ability to aggregate and infer information from a global context. In contrast, the RAG approach was limited to identifying individuals within a single document due to its chunking-based processing constraints. This highlights Graphrag's superior capability in comprehensively resolving queries that span across a broader corpus of interconnected data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 7. Finding Related Nodes\n",
+    "\n",
+    "Explore relationships in the knowledge graph:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "related_nodes = await cogneeRAG.get_related_nodes(\"person\")\n",
+    "\n",
+    "print(\"\\n\\nRelated nodes are:\\n\")\n",
+    "for node in related_nodes:\n",
+    "    print(f\"{node}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Why Choose Cognee and LlamaIndex?\n",
+    "\n",
+    "### 1. Agentic Framework and Memory tied together\n",
+    "\n",
+    "Your agents can now get long-term, short-term memory and memory specific to their domains\n",
+    "\n",
+    "### 2. Enhanced Querying and Insights\n",
+    "\n",
+    "Your memory can now automatically optimize itself and allow to respond to questions better\n",
+    "\n",
+    "### 3. Simplified Deployment\n",
+    "\n",
+    "You can use the standard tools out of the box and get things done without much effort\n",
+    "\n",
+    "## Visualizing the Knowledge Graph\n",
+    "\n",
+    "Imagine a graph structure where each node represents a document or entity, and edges indicate relationships.\n",
+    "\n",
+    "Here’s the visualized knowledge graph from the simple example above:\n",
+    "\n",
+    "![example.png](data:image/jpeg;base64,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)\n",
+    "\n",
+    "\n",
+    "## Conclusion\n",
+    "\n",
+    "Try running it yourself\n",
+    "\n",
+    "[join the cognee community](https://discord.gg/tV7pr5XSj7)"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/llama-index-core/llama_index/core/node_parser/relational/utils.py b/llama-index-core/llama_index/core/node_parser/relational/utils.py
index 19c7a3732..4d51c8373 100644
--- a/llama-index-core/llama_index/core/node_parser/relational/utils.py
+++ b/llama-index-core/llama_index/core/node_parser/relational/utils.py
@@ -31,7 +31,10 @@ def md_to_df(md_str: str) -> Any:
         return None
 
     # Use pandas to read the CSV string into a DataFrame
-    return pd.read_csv(StringIO(md_str))
+    try:
+        return pd.read_csv(StringIO(md_str))
+    except pd.errors.ParserError:
+        return None
 
 
 def html_to_df(html_str: str) -> Any:
diff --git a/llama-index-core/llama_index/core/schema.py b/llama-index-core/llama_index/core/schema.py
index 045f7122c..5b3c1d930 100644
--- a/llama-index-core/llama_index/core/schema.py
+++ b/llama-index-core/llama_index/core/schema.py
@@ -43,9 +43,9 @@ from llama_index.core.bridge.pydantic import (
     SerializationInfo,
     SerializeAsAny,
     SerializerFunctionWrapHandler,
-    model_serializer,
-    field_validator,
     ValidationInfo,
+    field_validator,
+    model_serializer,
 )
 from llama_index.core.bridge.pydantic_core import CoreSchema
 from llama_index.core.instrumentation import DispatcherSpanMixin
@@ -512,6 +512,11 @@ class MediaResource(BaseModel):
         default=None, description="MIME type of this resource."
     )
 
+    model_config = {
+        # This ensures validation runs even for None values
+        "validate_default": True
+    }
+
     @field_validator("data", mode="after")
     @classmethod
     def validate_data(cls, v: bytes | None, info: ValidationInfo) -> bytes | None:
@@ -525,11 +530,19 @@ class MediaResource(BaseModel):
             return v
 
         try:
-            # Check if data is already base64 encoded
-            base64.b64decode(v)
+            # Check if data is already base64 encoded.
+            # b64decode() can succeed on random binary data, we make
+            # a full roundtrip to make sure it's not a false positive
+            decoded = base64.b64decode(v)
+            encoded = base64.b64encode(decoded)
+            if encoded != v:
+                # Roundtrip failed, this is a false positive, return encoded
+                return base64.b64encode(v)
         except Exception:
-            v = base64.b64encode(v)
+            # b64decode failed, return encoded
+            return base64.b64encode(v)
 
+        # Good as is, return unchanged
         return v
 
     @field_validator("mimetype", mode="after")
@@ -540,7 +553,7 @@ class MediaResource(BaseModel):
 
         # Since this field validator runs after the one for `data`
         # then the contents of `data` should be encoded already
-        b64_data = info.data["data"]
+        b64_data = info.data.get("data")
         if b64_data:  # encoded bytes
             decoded_data = base64.b64decode(b64_data)
             if guess := filetype.guess(decoded_data):
@@ -780,7 +793,7 @@ class ImageNode(TextNode):
                 kwargs["image_url"] = ir.get("url", None)
                 kwargs["image_mimetype"] = ir.get("mimetype", None)
 
-        mimetype = kwargs.get("image_mimetype", None)
+        mimetype = kwargs.get("image_mimetype")
         if not mimetype and "image_path" in kwargs:
             # guess mimetype from image_path
             extension = Path(kwargs["image_path"]).suffix.replace(".", "")
@@ -1178,11 +1191,17 @@ class ImageDocument(Document):
         text_embedding = kwargs.pop("text_embedding", None)
 
         if image:
-            kwargs["image_resource"] = MediaResource(data=image)
+            kwargs["image_resource"] = MediaResource(
+                data=image, mimetype=image_mimetype
+            )
         elif image_path:
-            kwargs["image_resource"] = MediaResource(path=image_path)
+            kwargs["image_resource"] = MediaResource(
+                path=image_path, mimetype=image_mimetype
+            )
         elif image_url:
-            kwargs["image_resource"] = MediaResource(url=image_url)
+            kwargs["image_resource"] = MediaResource(
+                url=image_url, mimetype=image_mimetype
+            )
 
         super().__init__(**kwargs)
 
diff --git a/llama-index-integrations/graph_rag/llama-index-graph-rag-cognee/pyproject.toml b/llama-index-integrations/graph_rag/llama-index-graph-rag-cognee/pyproject.toml
index eec1ae943..f01a9a549 100644
--- a/llama-index-integrations/graph_rag/llama-index-graph-rag-cognee/pyproject.toml
+++ b/llama-index-integrations/graph_rag/llama-index-graph-rag-cognee/pyproject.toml
@@ -27,11 +27,11 @@ exclude = ["**/BUILD"]
 license = "MIT"
 name = "llama-index-graph-rag-cognee"
 readme = "README.md"
-version = "0.1.1"
+version = "0.1.2"
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.12"
-cognee = {extras = ["neo4j", "postgres", "qdrant", "weaviate"], version = "^0.1.21"}
+cognee = {extras = ["neo4j", "postgres", "qdrant", "weaviate"], version = "^0.1.22"}
 httpx = "~=0.27.0"
 llama-index-core = "^0.12.5"
 pytest-cov = "^6.0.0"


Test patch:
diff --git a/llama-index-core/tests/schema/test_media_resource.py b/llama-index-core/tests/schema/test_media_resource.py
index 8029ab3ef..ad696e3c9 100644
--- a/llama-index-core/tests/schema/test_media_resource.py
+++ b/llama-index-core/tests/schema/test_media_resource.py
@@ -14,19 +14,31 @@ def test_defaults():
 
 
 def test_mimetype():
-    png_1px = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
-    m = MediaResource(data=png_1px.encode("utf-8"), mimetype=None)
+    png_1px = b"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+    m = MediaResource(data=png_1px, mimetype=None)
     assert m.mimetype == "image/png"
 
 
+def test_mimetype_raw_data():
+    import requests
+
+    resp = requests.get(
+        "https://storage.googleapis.com/generativeai-downloads/data/scene.jpg"
+    )
+    m = MediaResource(data=resp.content)
+    assert m.mimetype == "image/jpeg"
+
+
 def test_mimetype_from_path():
-    m = MediaResource(path="my-image.jpg", mimetype=None)
+    m = MediaResource(path=Path("my-image.jpg"), mimetype=None)
     assert m.mimetype == "image/jpeg"
 
 
 def test_mimetype_prioritizes_data():
     png_1px = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
-    m = MediaResource(data=png_1px.encode("utf-8"), mimetype=None, path="my_image.jpg")
+    m = MediaResource(
+        data=png_1px.encode("utf-8"), mimetype=None, path=Path("my_image.jpg")
+    )
     assert m.mimetype == "image/png"