langfuse-haystack 0.0.2__tar.gz → 0.0.4__tar.gz

langfuse_haystack-0.0.4/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.3
+Name: langfuse-haystack
+Version: 0.0.4
+Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme
+Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
+Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse
+Author-email: deepset GmbH <info@deepset.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: haystack-ai
+Requires-Dist: langfuse
+Description-Content-Type: text/markdown
+
+# langfuse-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+
+langfuse-haystack integrates tracing capabilities into [Haystack](https://github.com/deepset-ai/haystack) (2.x) pipelines using [Langfuse](https://langfuse.com/). This package enhances the visibility of pipeline runs by capturing comprehensive details of the execution traces, including API calls, context data, prompts, and more. Whether you're monitoring model performance, pinpointing areas for improvement, or creating datasets for fine-tuning and testing from your pipeline executions, langfuse-haystack is the right tool for you.
+## Features
+
+- Easy integration with Haystack pipelines
+- Capture the full context of the execution
+- Track model usage and cost
+- Collect user feedback
+- Identify low-quality outputs
+- Build fine-tuning and testing datasets
+
+## Installation
+
+To install langfuse-haystack, run the following command:
+
+```sh
+pip install langfuse-haystack
+```
+
+## Usage
+
+To enable tracing in your Haystack pipeline, add the `LangfuseConnector` to your pipeline.
+You also need to set the `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` environment variables in order to connect to Langfuse account.
+You can get these keys by signing up for an account on the Langfuse website.
+
+Here's an example:
+
+```python
+import os
+
+os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+from haystack.components.builders import DynamicChatPromptBuilder
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+from haystack import Pipeline
+
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+if __name__ == "__main__":
+    pipe = Pipeline()
+    pipe.add_component("tracer", LangfuseConnector("Chat example"))
+    pipe.add_component("prompt_builder", DynamicChatPromptBuilder())
+    pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+
+    messages = [
+        ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
+        ChatMessage.from_user("Tell me about {{location}}"),
+    ]
+
+    response = pipe.run(
+        data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "prompt_source": messages}}
+    )
+    print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])
+```
+
+In this example, we add the `LangfuseConnector` to the pipeline with the name "tracer". Each run of the pipeline produces one trace viewable on the Langfuse website with a specific URL. The trace captures the entire execution context, including the prompts, completions, and metadata.
+
+## Trace Visualization
+
+Langfuse provides a user-friendly interface to visualize and analyze the traces generated by your Haystack pipeline. Login into your Langfuse account and navigate to the trace URL to view the trace details.
+
+## Contributing
+
+`hatch` is the best way to interact with this project. To install it, run:
+```sh
+pip install hatch
+```
+
+With `hatch` installed, run all the tests:
+```
+hatch run test
+```
+
+Run the linters `ruff` and `mypy`:
+```
+hatch run lint:all
+```
+
+## License
+
+`langfuse-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

langfuse_haystack-0.0.4/README.md

@@ -0,0 +1,91 @@
+# langfuse-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+
+langfuse-haystack integrates tracing capabilities into [Haystack](https://github.com/deepset-ai/haystack) (2.x) pipelines using [Langfuse](https://langfuse.com/). This package enhances the visibility of pipeline runs by capturing comprehensive details of the execution traces, including API calls, context data, prompts, and more. Whether you're monitoring model performance, pinpointing areas for improvement, or creating datasets for fine-tuning and testing from your pipeline executions, langfuse-haystack is the right tool for you.
+## Features
+
+- Easy integration with Haystack pipelines
+- Capture the full context of the execution
+- Track model usage and cost
+- Collect user feedback
+- Identify low-quality outputs
+- Build fine-tuning and testing datasets
+
+## Installation
+
+To install langfuse-haystack, run the following command:
+
+```sh
+pip install langfuse-haystack
+```
+
+## Usage
+
+To enable tracing in your Haystack pipeline, add the `LangfuseConnector` to your pipeline.
+You also need to set the `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` environment variables in order to connect to Langfuse account.
+You can get these keys by signing up for an account on the Langfuse website.
+
+Here's an example:
+
+```python
+import os
+
+os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+from haystack.components.builders import DynamicChatPromptBuilder
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+from haystack import Pipeline
+
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+if __name__ == "__main__":
+    pipe = Pipeline()
+    pipe.add_component("tracer", LangfuseConnector("Chat example"))
+    pipe.add_component("prompt_builder", DynamicChatPromptBuilder())
+    pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+
+    messages = [
+        ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
+        ChatMessage.from_user("Tell me about {{location}}"),
+    ]
+
+    response = pipe.run(
+        data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "prompt_source": messages}}
+    )
+    print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])
+```
+
+In this example, we add the `LangfuseConnector` to the pipeline with the name "tracer". Each run of the pipeline produces one trace viewable on the Langfuse website with a specific URL. The trace captures the entire execution context, including the prompts, completions, and metadata.
+
+## Trace Visualization
+
+Langfuse provides a user-friendly interface to visualize and analyze the traces generated by your Haystack pipeline. Login into your Langfuse account and navigate to the trace URL to view the trace details.
+
+## Contributing
+
+`hatch` is the best way to interact with this project. To install it, run:
+```sh
+pip install hatch
+```
+
+With `hatch` installed, run all the tests:
+```
+hatch run test
+```
+
+Run the linters `ruff` and `mypy`:
+```
+hatch run lint:all
+```
+
+## License
+
+`langfuse-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

{langfuse_haystack-0.0.2 → langfuse_haystack-0.0.4}/example/basic_rag.py

@@ -1,19 +1,16 @@
 import os
 
-os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 
 from datasets import load_dataset
-
-from haystack.document_stores.in_memory import InMemoryDocumentStore
 from haystack import Document, Pipeline
+from haystack.components.builders import PromptBuilder
 from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
-from haystack.components.retrievers import InMemoryEmbeddingRetriever
 from haystack.components.generators import OpenAIGenerator
-from haystack.components.builders import PromptBuilder
-
-from haystack_integrations.components.others.langfuse import LangfuseComponent
+from haystack.components.retrievers import InMemoryEmbeddingRetriever
+from haystack.document_stores.in_memory import InMemoryDocumentStore
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 
 
 def get_pipeline(document_store: InMemoryDocumentStore):
@@ -35,7 +32,7 @@ def get_pipeline(document_store: InMemoryDocumentStore):
 
     basic_rag_pipeline = Pipeline()
     # Add components to your pipeline
-    basic_rag_pipeline.add_component("tracer", LangfuseComponent("Basic RAG Pipeline"))
+    basic_rag_pipeline.add_component("tracer", LangfuseConnector("Basic RAG Pipeline"))
     basic_rag_pipeline.add_component(
         "text_embedder", SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
     )
@@ -65,3 +62,4 @@ if __name__ == "__main__":
     response = pipeline.run({"text_embedder": {"text": question}, "prompt_builder": {"question": question}})
 
     print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])

langfuse_haystack-0.0.4/example/chat.py

@@ -0,0 +1,29 @@
+import os
+
+os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+from haystack import Pipeline
+from haystack.components.builders import DynamicChatPromptBuilder
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+if __name__ == "__main__":
+
+    pipe = Pipeline()
+    pipe.add_component("tracer", LangfuseConnector("Chat example"))
+    pipe.add_component("prompt_builder", DynamicChatPromptBuilder())
+    pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+
+    messages = [
+        ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
+        ChatMessage.from_user("Tell me about {{location}}"),
+    ]
+
+    response = pipe.run(
+        data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "prompt_source": messages}}
+    )
+    print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])

langfuse_haystack-0.0.4/pydoc/config.yml

@@ -0,0 +1,30 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../src]
+    modules: [
+      "haystack_integrations.components.connectors.langfuse.langfuse_connector",
+      "haystack_integrations.tracing.langfuse.tracer",
+    ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmePreviewRenderer
+  excerpt: Langfuse integration for Haystack
+  category_slug: integrations-api
+  title: langfuse
+  slug: integrations-langfuse
+  order: 135
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: _readme_langfuse.md

{langfuse_haystack-0.0.2 → langfuse_haystack-0.0.4}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [project]
@@ -38,10 +38,8 @@ Source = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/int
 packages = ["src/haystack_integrations"]
 
 [tool.hatch.version]
-# Remove the following line and uncomment the others to enable git versioning
-path = "src/haystack_integrations/components/others/langfuse/__about__.py"
-# source = "vcs"
-# tag-pattern = 'integrations\/langfuse-v(?P<version>.*)'
+source = "vcs"
+tag-pattern = 'integrations\/langfuse-v(?P<version>.*)'
 
 
 [tool.hatch.version.raw-options]
@@ -52,6 +50,7 @@ git_describe_command = 'git describe --tags --match="integrations/langfuse-v[0-9
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
+  "haystack-pydoc-tools",
 ]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"

langfuse_haystack-0.0.4/src/haystack_integrations/components/connectors/langfuse/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from .langfuse_connector import LangfuseConnector
+
+__all__ = ["LangfuseConnector"]

langfuse_haystack-0.0.4/src/haystack_integrations/components/connectors/langfuse/langfuse_connector.py

@@ -0,0 +1,82 @@
+from haystack import component, tracing
+from haystack_integrations.tracing.langfuse import LangfuseTracer
+
+from langfuse import Langfuse
+
+
+@component
+class LangfuseConnector:
+    """
+    LangfuseConnector connects Haystack LLM framework with Langfuse in order to enable the tracing of operations
+    and data flow within various components of a pipeline.
+
+    Simply add this component to your pipeline, but *do not* connect it to any other component. The LangfuseConnector
+    will automatically trace the operations and data flow within the pipeline.
+
+    Note that you need to set the `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` environment variables in order
+    to use this component. The `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` are the secret and public keys provided
+    by Langfuse. You can get these keys by signing up for an account on the Langfuse website.
+
+    In addition, you need to set the `HAYSTACK_CONTENT_TRACING_ENABLED` environment variable to `true` in order to
+    enable Haystack tracing in your pipeline.
+
+    Here is an example of how to use it:
+
+    ```python
+    import os
+
+    os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+    from haystack import Pipeline
+    from haystack.components.builders import DynamicChatPromptBuilder
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.dataclasses import ChatMessage
+    from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+    if __name__ == "__main__":
+
+        pipe = Pipeline()
+        pipe.add_component("tracer", LangfuseConnector("Chat example"))
+        pipe.add_component("prompt_builder", DynamicChatPromptBuilder())
+        pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+
+        pipe.connect("prompt_builder.prompt", "llm.messages")
+
+        messages = [
+            ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
+            ChatMessage.from_user("Tell me about {{location}}"),
+        ]
+
+        response = pipe.run(
+            data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "prompt_source": messages}}
+        )
+        print(response["llm"]["replies"][0])
+        print(response["tracer"]["trace_url"])
+    ```
+
+    """
+
+    def __init__(self, name: str, public: bool = False):
+        """
+        Initialize the LangfuseConnector component.
+
+        :param name: The name of the pipeline or component. This name will be used to identify the tracing run on the
+            Langfuse dashboard.
+        :param public: Whether the tracing data should be public or private. If set to `True`, the tracing data will be
+            publicly accessible to anyone with the tracing URL. If set to `False`, the tracing data will be private and
+            only accessible to the Langfuse account owner. The default is `False`.
+        """
+        self.name = name
+        self.tracer = LangfuseTracer(tracer=Langfuse(), name=name, public=public)
+        tracing.enable_tracing(self.tracer)
+
+    @component.output_types(name=str, trace_url=str)
+    def run(self):
+        """
+        Runs the LangfuseConnector component.
+
+        :returns: A dictionary with the following keys:
+            - `name`: The name of the tracing component.
+            - `trace_url`: The URL to the tracing data.
+        """
+        return {"name": self.name, "trace_url": self.tracer.get_trace_url()}

{langfuse_haystack-0.0.2 → langfuse_haystack-0.0.4}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -1,6 +1,7 @@
 import contextlib
 from typing import Any, Dict, Iterator, Optional, Union
 
+from haystack.dataclasses import ChatMessage
 from haystack.tracing import Span, Tracer, tracer
 from haystack.tracing import utils as tracing_utils
 
@@ -11,7 +12,7 @@ class LangfuseSpan(Span):
     def __init__(self, span: "Union[langfuse.client.StatefulSpanClient, langfuse.client.StatefulTraceClient]") -> None:
         self._span = span
         # locally cache tags
-        self._data = {}
+        self._data: Dict[str, Any] = {}
 
     def set_tag(self, key: str, value: Any) -> None:
         coerced_value = tracing_utils.coerce_tag_value(value)
@@ -21,11 +22,21 @@ class LangfuseSpan(Span):
     def set_content_tag(self, key: str, value: Any) -> None:
         if not tracer.is_content_tracing_enabled:
             return
-
         if key.endswith(".input"):
-            self._span.update(input=value)
+            if "messages" in value:
+                messages = [self.to_openai_format(m) for m in value["messages"]]
+                self._span.update(input=messages)
+            else:
+                self._span.update(input=value)
         elif key.endswith(".output"):
-            self._span.update(output=value)
+            if "replies" in value:
+                if all(isinstance(r, ChatMessage) for r in value["replies"]):
+                    replies = [self.to_openai_format(m) for m in value["replies"]]
+                else:
+                    replies = value["replies"]
+                self._span.update(output=replies)
+            else:
+                self._span.update(output=value)
 
         self._data[key] = value
 
@@ -35,22 +46,31 @@ class LangfuseSpan(Span):
     def get_correlation_data_for_logs(self) -> Dict[str, Any]:
         return {}
 
+    def to_openai_format(self, m: ChatMessage) -> Dict[str, Any]:
+        """
+        Remove after haystack 2.0.1 has been released and use the `to_openai_format` method from the ChatMessage class
+        """
+        msg = {"role": m.role.value, "content": m.content}
+        if m.name:
+            msg["name"] = m.name
+
+        return msg
+
 
 class LangfuseTracer(Tracer):
-    def __init__(self, tracer: "langfuse.Langfuse", name: str = "Haystack") -> None:
+    def __init__(self, tracer: "langfuse.Langfuse", name: str = "Haystack", public: bool = False) -> None:
         self._tracer = tracer
         self._context: list[LangfuseSpan] = []
         self._name = name
+        self._public = public
 
     @contextlib.contextmanager
     def trace(self, operation_name: str, tags: Optional[Dict[str, Any]] = None) -> Iterator[Span]:
         tags = tags or {}
         span_name = tags.get("haystack.component.name", operation_name)
-        is_generation = False
 
-        if tags.get("haystack.component.type") in ["OpenAIGenerator"]:
+        if tags.get("haystack.component.type") in ["OpenAIGenerator", "OpenAIChatGenerator"]:
             span = LangfuseSpan(self.current_span().raw_span().generation(name=span_name))
-            is_generation = True
         else:
             span = LangfuseSpan(self.current_span().raw_span().span(name=span_name))
 
@@ -59,13 +79,25 @@ class LangfuseTracer(Tracer):
 
         yield span
 
-        if is_generation:
+        if tags.get("haystack.component.type") == "OpenAIGenerator":
             meta = span._data.get("haystack.component.output", {}).get("meta")
             if meta:
                 # Haystack returns one meta dict for each message, but the 'usage' value
                 # is always the same, let's just pick the first item
                 m = meta[0]
                 span._span.update(usage=m.get("usage"), model=m.get("model"))
+        elif tags.get("haystack.component.type") == "OpenAIChatGenerator":
+            replies = span._data.get("haystack.component.output", {}).get("replies")
+            if replies:
+                meta = replies[0].meta
+                span._span.update(usage=meta.get("usage"), model=meta.get("model"))
+
+        pipeline_input = tags.get("haystack.pipeline.input_data", None)
+        if pipeline_input:
+            span._span.update(input=tags["haystack.pipeline.input_data"])
+        pipeline_output = tags.get("haystack.pipeline.output_data", None)
+        if pipeline_output:
+            span._span.update(output=tags["haystack.pipeline.output_data"])
 
         span.raw_span().end()
         self._context.pop()
@@ -74,5 +106,8 @@ class LangfuseTracer(Tracer):
     def current_span(self) -> Span:
         if not self._context:
             # The root span has to be a trace
-            self._context.append(LangfuseSpan(self._tracer.trace(name=self._name)))
+            self._context.append(LangfuseSpan(self._tracer.trace(name=self._name, public=self._public)))
         return self._context[-1]
+
+    def get_trace_url(self) -> str:
+        return self._tracer.get_trace_url()

langfuse_haystack-0.0.4/tests/test_tracing.py

@@ -0,0 +1,57 @@
+import os
+
+# don't remove (or move) this env var setting from here, it's needed to turn tracing on
+os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+from urllib.parse import urlparse
+
+import pytest
+import requests
+
+from haystack import Pipeline
+from haystack.components.builders import DynamicChatPromptBuilder
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+from requests.auth import HTTPBasicAuth
+
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(
+    not os.environ.get("LANGFUSE_SECRET_KEY", None) and not os.environ.get("LANGFUSE_PUBLIC_KEY", None),
+    reason="Export an env var called LANGFUSE_SECRET_KEY and LANGFUSE_PUBLIC_KEY containing Langfuse credentials.",
+)
+def test_tracing_integration():
+
+    pipe = Pipeline()
+    pipe.add_component("tracer", LangfuseConnector(name="Chat example", public=True))  # public so anyone can verify run
+    pipe.add_component("prompt_builder", DynamicChatPromptBuilder())
+    pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+
+    messages = [
+        ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
+        ChatMessage.from_user("Tell me about {{location}}"),
+    ]
+
+    response = pipe.run(
+        data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "prompt_source": messages}}
+    )
+    assert "Berlin" in response["llm"]["replies"][0].content
+    assert response["tracer"]["trace_url"]
+    url = "https://cloud.langfuse.com/api/public/traces/"
+    trace_url = response["tracer"]["trace_url"]
+    parsed_url = urlparse(trace_url)
+    # trace id is the last part of the path (after the last '/')
+    uuid = os.path.basename(parsed_url.path)
+    try:
+        # GET request with Basic Authentication on the Langfuse API
+        response = requests.get(
+            url + uuid, auth=HTTPBasicAuth(os.environ.get("LANGFUSE_PUBLIC_KEY"), os.environ.get("LANGFUSE_SECRET_KEY"))
+        )
+
+        assert response.status_code == 200, f"Failed to retrieve data from Langfuse API: {response.status_code}"
+    except requests.exceptions.RequestException as e:
+        assert False, f"Failed to retrieve data from Langfuse API: {e}"

langfuse_haystack-0.0.2/PKG-INFO

@@ -1,45 +0,0 @@
-Metadata-Version: 2.3
-Name: langfuse-haystack
-Version: 0.0.2
-Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme
-Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
-Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse
-Author-email: deepset GmbH <info@deepset.ai>
-License-Expression: Apache-2.0
-License-File: LICENSE.txt
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8
-Requires-Dist: haystack-ai
-Requires-Dist: langfuse
-Description-Content-Type: text/markdown
-
-# langfuse
-
-[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-
------
-
-**Table of Contents**
-
-- [langfuse](#langfuse)
-  - [Installation](#installation)
-  - [License](#license)
-
-## Installation
-
-```console
-pip install langfuse-haystack
-```
-
-## License
-
-`langfuse` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

langfuse_haystack-0.0.2/README.md

@@ -1,22 +0,0 @@
-# langfuse
-
-[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-
------
-
-**Table of Contents**
-
-- [langfuse](#langfuse)
-  - [Installation](#installation)
-  - [License](#license)
-
-## Installation
-
-```console
-pip install langfuse-haystack
-```
-
-## License
-
-`langfuse` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

langfuse_haystack-0.0.2/src/haystack_integrations/components/others/langfuse/__about__.py

@@ -1 +0,0 @@
-__version__ = "0.0.2"

langfuse_haystack-0.0.2/src/haystack_integrations/components/others/langfuse/__init__.py

@@ -1,3 +0,0 @@
-from .langfuse import LangfuseComponent
-
-__all__ = ["LangfuseComponent"]

langfuse_haystack-0.0.2/src/haystack_integrations/components/others/langfuse/langfuse.py

@@ -1,18 +0,0 @@
-from haystack import tracing, component
-
-from haystack_integrations.tracing.langfuse import LangfuseTracer
-
-from langfuse import Langfuse
-
-# from langfuse.openai import openai  # noqa
-
-
-@component
-class LangfuseComponent:
-    def __init__(self, name: str):
-        self.name = name
-        tracing.enable_tracing(LangfuseTracer(Langfuse(), name))
-
-    @component.output_types(name=str)
-    def run(self):
-        return {"name": self.name}