lmnr 0.6.8__py3-none-any.whl → 0.6.10__py3-none-any.whl

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/utils.py

@@ -0,0 +1,60 @@
+import logging
+import traceback
+
+import pydantic
+from opentelemetry.trace import Span
+from typing import Any
+
+
+def set_span_attribute(span: Span, name: str, value: str):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            logger.debug(
+                "Laminar failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+
+    return wrapper
+
+
+def to_dict(obj: pydantic.BaseModel | dict) -> dict[str, Any]:
+    try:
+        if isinstance(obj, pydantic.BaseModel):
+            return obj.model_dump()
+        elif isinstance(obj, dict):
+            return obj
+        else:
+            return dict(obj)
+    except Exception:
+        return dict(obj)
+
+
+def with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -1,5 +1,6 @@
 import atexit
 import logging
+import threading
 
 from lmnr.opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
@@ -16,12 +17,6 @@ from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider, SpanProcessor
 from opentelemetry.sdk.trace.export import SpanExporter
 
-module_logger = logging.getLogger(__name__)
-console_log_handler = logging.StreamHandler()
-console_log_handler.setFormatter(VerboseColorfulFormatter())
-module_logger.addHandler(console_log_handler)
-
-
 TRACER_NAME = "lmnr.tracer"
 
 MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
@@ -30,12 +25,13 @@ MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
-    __tracer_provider: TracerProvider | None = None
-    __logger: logging.Logger
-    __client: LaminarClient
-    __async_client: AsyncLaminarClient
-    __resource: Resource
-    __span_processor: SpanProcessor
+    _lock = threading.Lock()
+    _tracer_provider: TracerProvider | None = None
+    _logger: logging.Logger
+    _client: LaminarClient
+    _async_client: AsyncLaminarClient
+    _resource: Resource
+    _span_processor: SpanProcessor
 
     def __new__(
         cls,
@@ -57,73 +53,76 @@ class TracerWrapper(object):
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
 
         base_http_url = f"{base_url}:{http_port}"
-        cls._initialize_logger(cls)
-        if not hasattr(cls, "instance"):
-            obj = cls.instance = super(TracerWrapper, cls).__new__(cls)
-
-            obj.__client = LaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
-            obj.__async_client = AsyncLaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
-
-            obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
-
-            obj.__span_processor = LaminarSpanProcessor(
-                base_url=base_url,
-                api_key=project_api_key,
-                port=http_port if force_http else port,
-                exporter=exporter,
-                max_export_batch_size=max_export_batch_size,
-                timeout_seconds=timeout_seconds,
-                force_http=force_http,
-                disable_batch=disable_batch,
-            )
-
-            lmnr_provider = TracerProvider(resource=obj.__resource)
-            global_provider = trace.get_tracer_provider()
-            if set_global_tracer_provider and isinstance(
-                global_provider, trace.ProxyTracerProvider
-            ):
-                trace.set_tracer_provider(lmnr_provider)
-
-            obj.__tracer_provider = lmnr_provider
-
-            obj.__tracer_provider.add_span_processor(obj.__span_processor)
-
-            # This is not a real instrumentation and does not generate telemetry
-            # data, but it is required to ensure that OpenTelemetry context
-            # propagation is enabled.
-            # See the README at:
-            # https://pypi.org/project/opentelemetry-instrumentation-threading/
-            ThreadingInstrumentor().instrument()
-
-            init_instrumentations(
-                tracer_provider=obj.__tracer_provider,
-                instruments=instruments,
-                block_instruments=block_instruments,
-                client=obj.__client,
-                async_client=obj.__async_client,
-            )
-
-            # Force flushes for debug environments (e.g. local development)
-            atexit.register(obj.exit_handler)
-
-        return cls.instance
+        with cls._lock:
+            if not hasattr(cls, "instance"):
+                cls._initialize_logger(cls)
+                obj = super(TracerWrapper, cls).__new__(cls)
+
+                obj._client = LaminarClient(
+                    base_url=base_http_url,
+                    project_api_key=project_api_key,
+                )
+                obj._async_client = AsyncLaminarClient(
+                    base_url=base_http_url,
+                    project_api_key=project_api_key,
+                )
+
+                obj._resource = Resource(attributes=TracerWrapper.resource_attributes)
+
+                obj._span_processor = LaminarSpanProcessor(
+                    base_url=base_url,
+                    api_key=project_api_key,
+                    port=http_port if force_http else port,
+                    exporter=exporter,
+                    max_export_batch_size=max_export_batch_size,
+                    timeout_seconds=timeout_seconds,
+                    force_http=force_http,
+                    disable_batch=disable_batch,
+                )
+
+                lmnr_provider = TracerProvider(resource=obj._resource)
+                global_provider = trace.get_tracer_provider()
+                if set_global_tracer_provider and isinstance(
+                    global_provider, trace.ProxyTracerProvider
+                ):
+                    trace.set_tracer_provider(lmnr_provider)
+
+                obj._tracer_provider = lmnr_provider
+
+                obj._tracer_provider.add_span_processor(obj._span_processor)
+
+                # This is not a real instrumentation and does not generate telemetry
+                # data, but it is required to ensure that OpenTelemetry context
+                # propagation is enabled.
+                # See the README at:
+                # https://pypi.org/project/opentelemetry-instrumentation-threading/
+                ThreadingInstrumentor().instrument()
+
+                init_instrumentations(
+                    tracer_provider=obj._tracer_provider,
+                    instruments=instruments,
+                    block_instruments=block_instruments,
+                    client=obj._client,
+                    async_client=obj._async_client,
+                )
+
+                cls.instance = obj
+
+                # Force flushes for debug environments (e.g. local development)
+                atexit.register(obj.exit_handler)
+
+            return cls.instance
 
     def exit_handler(self):
-        if isinstance(self.__span_processor, LaminarSpanProcessor):
-            self.__span_processor.clear()
+        if isinstance(self._span_processor, LaminarSpanProcessor):
+            self._span_processor.clear()
         self.flush()
 
     def _initialize_logger(self):
-        self.__logger = logging.getLogger(__name__)
+        self._logger = logging.getLogger(__name__)
         console_log_handler = logging.StreamHandler()
         console_log_handler.setFormatter(VerboseColorfulFormatter())
-        self.__logger.addHandler(console_log_handler)
+        self._logger.addHandler(console_log_handler)
 
     @staticmethod
     def set_static_params(
@@ -135,23 +134,29 @@ class TracerWrapper(object):
 
     @classmethod
     def verify_initialized(cls) -> bool:
-        return hasattr(cls, "instance")
+        with cls._lock:
+            return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
 
     @classmethod
     def clear(cls):
+        if not cls.verify_initialized():
+            return
         # Any state cleanup. Now used in between tests
-        if isinstance(cls.instance.__span_processor, LaminarSpanProcessor):
-            cls.instance.__span_processor.clear()
+        if isinstance(cls.instance._span_processor, LaminarSpanProcessor):
+            cls.instance._span_processor.clear()
 
     def shutdown(self):
-        if self.__tracer_provider is None:
+        if self._tracer_provider is None:
             return
-        self.__tracer_provider.shutdown()
+        self._tracer_provider.shutdown()
 
     def flush(self):
-        return self.__span_processor.force_flush()
+        if not hasattr(self, "_span_processor"):
+            self._logger.warning("TracerWrapper not fully initialized, cannot flush")
+            return False
+        return self._span_processor.force_flush()
 
     def get_tracer(self):
-        if self.__tracer_provider is None:
+        if self._tracer_provider is None:
             return trace.get_tracer_provider().get_tracer(TRACER_NAME)
-        return self.__tracer_provider.get_tracer(TRACER_NAME)
+        return self._tracer_provider.get_tracer(TRACER_NAME)

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -171,6 +171,18 @@ class LangchainInstrumentorInitializer(InstrumentorInitializer):
         return LangchainInstrumentor()
 
 
+class LanggraphInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("langgraph"):
+            return None
+        if not is_package_installed("langchain-core"):
+            return None
+
+        from ..opentelemetry.instrumentation.langgraph import LanggraphInstrumentor
+
+        return LanggraphInstrumentor()
+
+
 class LlamaIndexInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not (

lmnr/opentelemetry_lib/tracing/context_properties.py

@@ -6,7 +6,7 @@ from lmnr.opentelemetry_lib.tracing.attributes import (
 )
 
 from opentelemetry.context import Context, attach, set_value, get_value
-from opentelemetry.trace import Span
+from opentelemetry.sdk.trace import Span
 from opentelemetry import trace
 
 
@@ -51,8 +51,15 @@ def remove_association_properties(properties: dict) -> None:
 
 
 def _set_association_properties_attributes(span: Span, properties: dict) -> None:
+    if not span.is_recording():
+        return
     for key, value in properties.items():
         if key == TRACING_LEVEL:
             span.set_attribute(f"lmnr.internal.{TRACING_LEVEL}", value)
             continue
+        if (
+            key in ["langgraph.edges", "langgraph.nodes"]
+            and span.name != "LangGraph.workflow"
+        ):
+            continue
         span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{key}", value)

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -26,6 +26,7 @@ class Instruments(Enum):
     HAYSTACK = "haystack"
     LANCEDB = "lancedb"
     LANGCHAIN = "langchain"
+    LANGGRAPH = "langgraph"
     LLAMA_INDEX = "llama_index"
     MARQO = "marqo"
     MCP = "mcp"
@@ -62,6 +63,7 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.HAYSTACK: initializers.HaystackInstrumentorInitializer(),
     Instruments.LANCEDB: initializers.LanceDBInstrumentorInitializer(),
     Instruments.LANGCHAIN: initializers.LangchainInstrumentorInitializer(),
+    Instruments.LANGGRAPH: initializers.LanggraphInstrumentorInitializer(),
     Instruments.LLAMA_INDEX: initializers.LlamaIndexInstrumentorInitializer(),
     Instruments.MARQO: initializers.MarqoInstrumentorInitializer(),
     Instruments.MCP: initializers.MCPInstrumentorInitializer(),

lmnr/opentelemetry_lib/tracing/processor.py

@@ -6,7 +6,7 @@ from opentelemetry.sdk.trace.export import (
     BatchSpanProcessor,
     SimpleSpanProcessor,
 )
-from opentelemetry.trace import Span
+from opentelemetry.sdk.trace import Span
 from opentelemetry.context import Context, get_value, get_current, set_value
 
 from lmnr.opentelemetry_lib.tracing.attributes import (

lmnr/sdk/client/asynchronous/resources/evals.py

@@ -33,6 +33,10 @@ class AsyncEvals(BaseAsyncResource):
             },
             headers=self._headers(),
         )
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise ValueError("Unauthorized. Please check your project API key.")
+            raise ValueError(f"Error initializing evaluation: {response.text}")
         resp_json = response.json()
         return InitEvaluationResponse.model_validate(resp_json)
 

lmnr/sdk/client/synchronous/resources/evals.py

@@ -35,6 +35,10 @@ class Evals(BaseResource):
             },
             headers=self._headers(),
         )
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise ValueError("Unauthorized. Please check your project API key.")
+            raise ValueError(f"Error initializing evaluation: {response.text}")
         resp_json = response.json()
         return InitEvaluationResponse.model_validate(resp_json)
 

lmnr/sdk/evaluations.py

@@ -199,11 +199,11 @@ class Evaluation:
         self.base_http_url = f"{base_url}:{http_port or 443}"
 
         api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
-        if not api_key:
+        if not api_key and not L.is_initialized():
             raise ValueError(
-                "Please initialize the Laminar object with"
-                " your project API key or set the LMNR_PROJECT_API_KEY"
-                " environment variable in your environment or .env file"
+                "Please pass the project API key to `evaluate`"
+                " or set the LMNR_PROJECT_API_KEY environment variable"
+                " in your environment or .env file"
             )
         self.project_api_key = api_key
 
@@ -212,17 +212,12 @@ class Evaluation:
                 base_url=L.get_base_http_url(),
                 project_api_key=L.get_project_api_key(),
             )
-            if project_api_key and project_api_key != L.get_project_api_key():
-                self._logger.warning(
-                    "Project API key is different from the one used to initialize"
-                    " Laminar. Ignoring the project API key passed to the evaluation."
-                )
-            return
+        else:
+            self.client = AsyncLaminarClient(
+                base_url=self.base_http_url,
+                project_api_key=self.project_api_key,
+            )
 
-        self.client = AsyncLaminarClient(
-            base_url=self.base_http_url,
-            project_api_key=self.project_api_key,
-        )
         L.initialize(
             project_api_key=project_api_key,
             base_url=base_url,
@@ -233,10 +228,10 @@ class Evaluation:
             export_timeout_seconds=trace_export_timeout_seconds,
         )
 
-    async def run(self) -> Awaitable[None]:
+    async def run(self) -> Awaitable[dict[str, int | float]]:
         return await self._run()
 
-    async def _run(self) -> None:
+    async def _run(self) -> dict[str, int | float]:
         if isinstance(self.data, LaminarDataset):
             self.data.set_client(
                 LaminarClient(
@@ -261,11 +256,12 @@ class Evaluation:
         except Exception as e:
             self.reporter.stopWithError(e)
             await self._shutdown()
-            return
+            raise
 
         average_scores = get_average_scores(result_datapoints)
         self.reporter.stop(average_scores, evaluation.projectId, evaluation.id)
         await self._shutdown()
+        return average_scores
 
     async def _shutdown(self):
         # We use flush() instead of shutdown() because multiple evaluations

lmnr/sdk/laminar.py

@@ -114,6 +114,12 @@ class Laminar:
         Raises:
             ValueError: If project API key is not set
         """
+        if cls.is_initialized():
+            cls.__logger.info(
+                "Laminar is already initialized. Skipping initialization."
+            )
+            return
+
         cls.__project_api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
         if not cls.__project_api_key:
             raise ValueError(
@@ -691,6 +697,7 @@ class Laminar:
     def shutdown(cls):
         if cls.is_initialized():
             TracerManager.shutdown()
+            cls.__initialized = False
 
     @classmethod
     def set_span_tags(cls, tags: list[str]):

lmnr/sdk/types.py

@@ -81,7 +81,7 @@ class PartialEvaluationDatapoint(pydantic.BaseModel):
                 "traceId": str(self.trace_id),
                 "executorSpanId": str(self.executor_span_id),
                 "metadata": (
-                    serialize(self.metadata) if self.metadata is not None else None
+                    serialize(self.metadata) if self.metadata is not None else {}
                 ),
             }
         except Exception as e:
@@ -123,7 +123,7 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
                 "executorSpanId": str(self.executor_span_id),
                 "index": self.index,
                 "metadata": (
-                    serialize(self.metadata) if self.metadata is not None else None
+                    serialize(self.metadata) if self.metadata is not None else {}
                 ),
             }
         except Exception as e:

lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.6.8"
+__version__ = "0.6.10"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
 
 

{lmnr-0.6.8.dist-info → lmnr-0.6.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lmnr
-Version: 0.6.8
+Version: 0.6.10
 Summary: Python SDK for Laminar
 License: Apache-2.0
 Author: lmnr.ai
@@ -46,61 +46,61 @@ Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: opentelemetry-api (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.33.0)
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.5) ; extra == "alephalpha"
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.5) ; extra == "anthropic"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.5) ; extra == "bedrock"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.5) ; extra == "chromadb"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.5) ; extra == "cohere"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.5) ; extra == "crewai"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.5) ; extra == "google-generativeai"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.5) ; extra == "groq"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.5) ; extra == "haystack"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.5) ; extra == "lancedb"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.5) ; extra == "langchain"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.5) ; extra == "llamaindex"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.5) ; extra == "marqo"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.5) ; extra == "mcp"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.5) ; extra == "milvus"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.5) ; extra == "mistralai"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.5) ; extra == "ollama"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.5) ; extra == "openai"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.5) ; extra == "pinecone"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.5) ; extra == "qdrant"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.5) ; extra == "replicate"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.5) ; extra == "sagemaker"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "alephalpha"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "anthropic"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "bedrock"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "chromadb"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "cohere"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "crewai"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "google-generativeai"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "groq"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "haystack"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "lancedb"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "langchain"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "llamaindex"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "marqo"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "mcp"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "milvus"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "mistralai"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "ollama"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "openai"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "pinecone"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "qdrant"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "replicate"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "sagemaker"
 Requires-Dist: opentelemetry-instrumentation-threading (>=0.54b0)
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.5) ; extra == "together"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.5) ; extra == "transformers"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.5) ; extra == "vertexai"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.5) ; extra == "watsonx"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.5) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.5) ; extra == "weaviate"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "together"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "transformers"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "vertexai"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "watsonx"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "weaviate"
 Requires-Dist: opentelemetry-sdk (>=1.33.0)
 Requires-Dist: opentelemetry-semantic-conventions (>=0.54b0)
 Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.8)