chore: import upstream snapshot with attribution

docs-website/docs/pipeline-components/writers/cogneewriter.mdx

@@ -0,0 +1,136 @@
+---
+title: "CogneeWriter"
+id: cogneewriter
+slug: "/cogneewriter"
+description: "Writes ChatMessage objects to a CogneeMemoryStore as long-term memories."
+---
+
+# CogneeWriter
+
+Writes `ChatMessage` objects to a `CogneeMemoryStore` as long-term memories.
+
+<div className="key-value-table">
+
+|  |  |
+| --- | --- |
+| **Most common position in a pipeline** | After an [`Agent`](../agents-1/agent.mdx) or Chat Generator in memory-augmented pipelines |
+| **Mandatory init variables** | `memory_store`: A `CogneeMemoryStore` instance |
+| **Optional init variables** | `session_id`: When set, writes target the session-cache tier; when `None`, writes go to the permanent knowledge graph |
+| **Mandatory run variables** | `messages`: A list of `ChatMessage` objects |
+| **Optional run variables** | `user_id`: Cognee user ID to scope the write; pass `None` to use Cognee's default user |
+| **Output variables** | `messages_written`: The list of `ChatMessage` objects that were written (passed through unchanged) |
+| **API reference** | [Cognee](/reference/integrations-cognee#cogneewriter) |
+| **GitHub link** | https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/cognee |
+| **Package name** | `cognee-haystack` |
+
+</div>
+
+## Overview
+
+`CogneeWriter` persists a list of `ChatMessage` objects into a `CogneeMemoryStore`. Use it in a Haystack Pipeline to store conversation facts or user preferences after an Agent turn.
+
+Messages are passed through unchanged to the pipeline output (`messages_written`), making this component easy to chain after an Agent or generator without breaking the pipeline flow.
+
+The `session_id` init parameter controls which Cognee memory tier is targeted:
+
+- Omit `session_id` (or set it to `None`) to write to the **permanent knowledge graph** — Cognee runs LLM extraction during ingestion, producing rich graph-completion-ready nodes.
+- Set `session_id` to write to the **session cache** — fast writes with no LLM extraction, scoped to that session. Session content can later be promoted to the permanent graph via `CogneeMemoryStore.improve()`.
+
+The writer's `session_id` overrides the store's `session_id` per call, so a single store can back multiple writers targeting different memory tiers.
+
+## Installation
+
+Install the Cognee integration:
+
+```bash
+pip install cognee-haystack
+```
+
+Set your LLM API key (used by Cognee for graph extraction):
+
+```bash
+export LLM_API_KEY="your-llm-api-key"
+```
+
+Optionally, set a separate embedding API key (defaults to `LLM_API_KEY` when unset):
+
+```bash
+export EMBEDDING_API_KEY="your-embedding-api-key"
+```
+
+## Usage
+
+### On its own
+
+```python
+from haystack.dataclasses import ChatMessage
+
+from haystack_integrations.components.writers.cognee import CogneeWriter
+from haystack_integrations.memory_stores.cognee import CogneeMemoryStore
+
+store = CogneeMemoryStore()
+writer = CogneeWriter(memory_store=store)
+
+result = writer.run(
+    messages=[ChatMessage.from_user("Alice prefers concise Python examples.")],
+    user_id="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+)
+print(result["messages_written"])
+```
+
+To write to the session cache instead of the permanent graph, pass a `session_id`:
+
+```python
+session_writer = CogneeWriter(memory_store=store, session_id="alice_session_1")
+session_writer.run(
+    messages=[ChatMessage.from_user("Alice is currently debugging a vector store issue.")],
+    user_id="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+)
+```
+
+### In a Pipeline
+
+This example connects an Agent's full `messages` output to `CogneeWriter`, so Cognee stores the conversation turn in the permanent graph.
+
+```python
+from haystack import Pipeline
+from haystack.components.agents import Agent
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+
+from haystack_integrations.components.writers.cognee import CogneeWriter
+from haystack_integrations.memory_stores.cognee import CogneeMemoryStore
+
+store = CogneeMemoryStore(dataset_name="my_agent_memory")
+
+pipeline = Pipeline()
+pipeline.add_component(
+    "agent",
+    Agent(
+        chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
+        system_prompt=(
+            "Answer the user and preserve durable user facts or preferences for future conversations."
+        ),
+    ),
+)
+pipeline.add_component("writer", CogneeWriter(memory_store=store))
+
+pipeline.connect("agent.messages", "writer.messages")
+
+result = pipeline.run(
+    {
+        "agent": {
+            "messages": [
+                ChatMessage.from_user(
+                    "My name is Alice and I prefer concise Python examples.",
+                ),
+            ],
+        },
+        "writer": {
+            "user_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+        },
+    },
+)
+
+print(result["writer"]["messages_written"])
+```

docs-website/docs/pipeline-components/writers/documentwriter.mdx

@@ -0,0 +1,99 @@
+---
+title: "DocumentWriter"
+id: documentwriter
+slug: "/documentwriter"
+description: "Use this component to write documents into a Document Store of your choice."
+---
+
+# DocumentWriter
+
+Use this component to write documents into a Document Store of your choice.
+
+<div className="key-value-table">
+
+|  |  |
+| --- | --- |
+| **Most common position in a pipeline** | As the last component in an indexing pipeline                                                     |
+| **Mandatory init variables**           | `document_store`: A Document Store instance                                                       |
+| **Mandatory run variables**            | `documents`: A list of documents                                                                  |
+| **Output variables**                   | `documents_written`: The number of documents written (integer)                                    |
+| **API reference**                      | [Document Writers](/reference/document-writers-api)                                                      |
+| **GitHub link**                        | https://github.com/deepset-ai/haystack/blob/main/haystack/components/writers/document_writer.py |
+| **Package name** | `haystack-ai` |
+
+</div>
+
+## Overview
+
+`DocumentWriter` writes a list of documents into a Document Store of your choice. It’s typically used in an indexing pipeline as the final step after preprocessing documents and creating their embeddings.
+
+To use this component with a specific file type, make sure you use the correct [Converter](../converters.mdx) before it. For example, to use `DocumentWriter` with Markdown files, use the `MarkdownToDocument` component before `DocumentWriter` in your indexing pipeline.
+
+### DuplicatePolicy
+
+The `DuplicatePolicy` is a class that defines the different options for handling documents with the same ID in a `DocumentStore`. It has four possible values:
+
+- **NONE**: The default policy that relies on Document Store settings.
+- **OVERWRITE**: Indicates that if a document with the same ID already exists in the `DocumentStore`, it should be overwritten with the new document.
+- **SKIP**: If a document with the same ID already exists, the new document will be skipped and not added to the `DocumentStore`.
+- **FAIL**: Raises an error if a document with the same ID already exists in the `DocumentStore`. It prevents duplicate documents from being added.
+
+## Usage
+
+### On its own
+
+Below is an example of how to write two documents into an `InMemoryDocumentStore`:
+
+```python
+from haystack import Document
+from haystack.document_stores.in_memory import InMemoryDocumentStore
+from haystack.components.writers import DocumentWriter
+
+documents = [
+    Document(content="This is document 1"),
+    Document(content="This is document 2"),
+]
+
+document_store = InMemoryDocumentStore()
+document_writer = DocumentWriter(document_store=document_store)
+document_writer.run(documents=documents)
+```
+
+### In a pipeline
+
+Below is an example of an indexing pipeline that first uses the `SentenceTransformersDocumentEmbedder` to create embeddings of documents and then use the `DocumentWriter` to write the documents to an `InMemoryDocumentStore`:
+
+The examples on this page use Sentence Transformers embedders that have moved to the `sentence-transformers-haystack` package. Install it to run the examples:
+
+```shell
+pip install sentence-transformers-haystack
+```
+
+```python
+from haystack.pipeline import Pipeline
+from haystack.document_stores.in_memory import InMemoryDocumentStore
+from haystack.document_stores.types import DuplicatePolicy
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+)
+from haystack.components.writers import DocumentWriter
+
+documents = [
+    Document(content="This is document 1"),
+    Document(content="This is document 2"),
+]
+
+document_store = InMemoryDocumentStore()
+embedder = SentenceTransformersDocumentEmbedder()
+document_writer = DocumentWriter(
+    document_store=document_store,
+    policy=DuplicatePolicy.NONE,
+)
+
+indexing_pipeline = Pipeline()
+indexing_pipeline.add_component(instance=embedder, name="embedder")
+indexing_pipeline.add_component(instance=document_writer, name="writer")
+
+indexing_pipeline.connect("embedder", "writer")
+indexing_pipeline.run({"embedder": {"documents": documents}})
+```

docs-website/docs/pipeline-components/writers/mem0memorywriter.mdx

@@ -0,0 +1,119 @@
+---
+title: "Mem0MemoryWriter"
+id: mem0memorywriter
+slug: "/mem0memorywriter"
+description: "Writes ChatMessage objects to Mem0 as long-term memories."
+---
+
+# Mem0MemoryWriter
+
+Writes `ChatMessage` objects to Mem0 as long-term memories.
+
+<div className="key-value-table">
+
+|  |  |
+| --- | --- |
+| **Most common position in a pipeline** | After an [`Agent`](../agents-1/agent.mdx) or Chat Generator in memory-augmented pipelines |
+| **Mandatory init variables** | `memory_store`: A `Mem0MemoryStore` instance |
+| **Mandatory run variables** | `messages`: A list of `ChatMessage` objects; at least one Mem0 scope through `user_id`, `run_id`, `agent_id`, or `app_id` |
+| **Output variables** | `memories_written`: The number of memories written |
+| **Mem0 API docs** | [Add Memories](https://docs.mem0.ai/api-reference/memory/add-memories) |
+| **GitHub link** | https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/mem0 |
+| **Package name** | `mem0-haystack` |
+
+</div>
+
+## Overview
+
+`Mem0MemoryWriter` writes a list of `ChatMessage` objects to a `Mem0MemoryStore`. Use it near the end of a memory-augmented pipeline to persist conversation facts, user preferences, and durable project context for future runs.
+
+Scope written memories with at least one Mem0 entity ID: `user_id`, `run_id`, `agent_id`, or `app_id`. These are runtime inputs, so one pipeline instance can write memories for multiple users, sessions, agents, or applications.
+
+The `infer` init parameter controls how Mem0 stores the incoming messages:
+
+- `infer=True` lets Mem0 extract memories from the messages. This is useful when writing a full Agent turn that includes the user message, tool context, and final assistant response.
+- `infer=False` stores the supplied message text as-is. This is useful when the upstream component has already selected the exact memory text.
+
+### Installation
+
+Install the Mem0 integration:
+
+```shell
+pip install mem0-haystack
+```
+
+Set your Mem0 API key:
+
+```shell
+export MEM0_API_KEY="your-mem0-api-key"
+```
+
+## Usage
+
+### On its own
+
+```python
+from haystack.dataclasses import ChatMessage
+
+from haystack_integrations.components.writers.mem0 import Mem0MemoryWriter
+from haystack_integrations.memory_stores.mem0 import Mem0MemoryStore
+
+store = Mem0MemoryStore()
+writer = Mem0MemoryWriter(memory_store=store, infer=False)
+
+result = writer.run(
+    messages=[ChatMessage.from_user("Alice prefers concise Python examples.")],
+    user_id="alice",
+)
+
+print(result["memories_written"])
+```
+
+### In a Pipeline
+
+This example connects an Agent's full `messages` output to `Mem0MemoryWriter` with `infer=True`, so Mem0 can extract memories from the full turn context.
+
+```python
+from haystack import Pipeline
+from haystack.components.agents import Agent
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.components.generators.utils import print_streaming_chunk
+from haystack.dataclasses import ChatMessage
+
+from haystack_integrations.components.writers.mem0 import Mem0MemoryWriter
+from haystack_integrations.memory_stores.mem0 import Mem0MemoryStore
+
+store = Mem0MemoryStore()
+
+pipeline = Pipeline()
+pipeline.add_component(
+    "agent",
+    Agent(
+        chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
+        system_prompt=(
+            "Answer the user and preserve durable user facts or preferences for future conversations."
+        ),
+        streaming_callback=print_streaming_chunk,
+    ),
+)
+pipeline.add_component("writer", Mem0MemoryWriter(memory_store=store, infer=True))
+
+pipeline.connect("agent.messages", "writer.messages")
+
+result = pipeline.run(
+    {
+        "agent": {
+            "messages": [
+                ChatMessage.from_user(
+                    "My name is Alice and I prefer concise Python examples.",
+                ),
+            ],
+        },
+        "writer": {
+            "user_id": "alice",
+        },
+    },
+)
+
+print(result["writer"]["memories_written"])
+```