semvec/pypi-packages huggingface dataset:
traceloop-sdk 0.52.4
Traceloop Software Development Kit (SDK) for Python
Requires Python: <4,>=3.10

# traceloop-sdk

Traceloop’s Python SDK allows you to easily start monitoring and debugging your LLM execution. Tracing is done in a non-intrusive way, built on top of OpenTelemetry. You can choose to export the traces to Traceloop, or to your existing observability stack.

```python
Traceloop.init(app_name="joke_generation_service")

@workflow(name="joke_creation")
def create_joke():
    completion = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Tell me a joke about opentelemetry"}],
    )

    return completion.choices[0].message.content
```
opentelemetry-instrumentation-writer 0.52.4
OpenTelemetry Writer instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Writer Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-writer/">
    <img alt="PyPI version" src="https://badge.fury.io/py/opentelemetry-instrumentation-writer.svg">
</a>

This library allows tracing calls to any of Writer's endpoints sent with the official [Writer Python Library](https://github.com/writer/writer-python).

## Installation

```bash
pip install opentelemetry-instrumentation-writer
```

## Example usage

```python
from opentelemetry.instrumentation.writer import WriterInstrumentor

WriterInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-weaviate 0.52.4
OpenTelemetry Weaviate instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Weaviate Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-weaviate/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-weaviate.svg">
</a>

This library allows tracing client-side calls to Weaviate vector DB sent with the official [Weaviate library](https://github.com/weaviate/weaviate-python-client).

## Installation

```bash
pip install opentelemetry-instrumentation-weaviate
```

## Example usage

```python
from opentelemetry.instrumentation.weaviate import WeaviateInstrumentor

WeaviateInstrumentor().instrument()
```
opentelemetry-instrumentation-watsonx 0.52.4
OpenTelemetry IBM Watsonx Instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry IBM Watsonx Instrumentation

This library allows tracing IBM Watsonx prompts and completions sent with the official [IBM Watson Machine Learning library](https://ibm.github.io/watson-machine-learning-sdk/) and [IBM watsonx.ai library](https://ibm.github.io/watsonx-ai-python-sdk/).

## Installation

```bash
pip install opentelemetry-instrumentation-watsonx
```

## Example usage

```python
from opentelemetry.instrumentation.watsonx import WatsonxInstrumentor

WatsonxInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```

## SSL Issue

In case of SSL handshake issues (or similar ones) as follows:

```
E0423 17:04:25.197068000 6150713344 ssl_transport_security.cc:1420]    Handshake failed with fatal error SSL_ERROR_SSL: error:100000f7:SSL routines:OPENSSL_internal:WRONG_VERSION_NUMBER.
```

You can instruct the exporter with an environment variable to ignore SSL errors:

```bash
OTEL_EXPORTER_OTLP_INSECURE=true
```
opentelemetry-instrumentation-voyageai 0.52.4
OpenTelemetry Voyage AI instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Voyage AI Instrumentation

This library allows tracing Voyage AI API calls with OpenTelemetry.

## Installation

```bash
pip install opentelemetry-instrumentation-voyageai
```

## Usage

```python
from opentelemetry.instrumentation.voyageai import VoyageAIInstrumentor

VoyageAIInstrumentor().instrument()

# Now use Voyage AI as usual
import voyageai

client = voyageai.Client()

# Embeddings
result = client.embed(texts=["Hello, world!"], model="voyage-3")

# Reranking
result = client.rerank(
    query="What is the capital of France?",
    documents=["Paris is the capital of France.", "London is in England."],
    model="rerank-2.5"
)
```

## Semantic Conventions

This instrumentation follows the OpenTelemetry GenAI semantic conventions:

- `gen_ai.system`: "voyageai"
- `gen_ai.operation.name`: "embeddings" or "rerank"
- `gen_ai.request.model`: The model name
- `gen_ai.usage.input_tokens`: Token count from the response
- `gen_ai.embeddings.dimension.count`: Embedding vector dimension (for embed only)
opentelemetry-instrumentation-vertexai 0.52.4
OpenTelemetry Vertex AI instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry VertexAI Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-vertexai/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-vertexai.svg">
</a>

This library allows tracing VertexAI prompts and completions sent with the official [VertexAI library](https://github.com/googleapis/python-aiplatform).

## Installation

```bash
pip install opentelemetry-instrumentation-vertexai
```

## Example usage

```python
from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor

VertexAIInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-transformers 0.52.4
OpenTelemetry transformers instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry HuggingFace Transformers Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-transformers/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-transformers.svg">
</a>

This library allows tracing texte generation calls sent with the official [HuggingFace Transformers library](https://github.com/huggingface/transformers).

## Installation

```bash
pip install opentelemetry-instrumentation-transformers
```

## Example usage

```python
from opentelemetry.instrumentation.transformers import TransformersInstrumentor

TransformersInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-together 0.52.4
OpenTelemetry Together AI instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Together AI Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-together/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-together.svg">
</a>

This library allows tracing calls to any of Together AI's endpoints sent with the official [Together AI Library](https://github.com/togethercomputer/together-python).

## Installation

```bash
pip install opentelemetry-instrumentation-together
```

## Example usage

```python
from opentelemetry.instrumentation.together import TogetherAiInstrumentor

TogetherAiInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-sagemaker 0.52.4
OpenTelemetry SageMaker instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry SageMaker Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-sagemaker/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-sagemaker.svg">
</a>

This library allows tracing of any models deployed on Amazon SageMaker and invoked with [Boto3](https://github.com/boto/boto3) to SageMaker.

## Installation

```bash
pip install opentelemetry-instrumentation-sagemaker
```

## Example usage

```python
from opentelemetry.instrumentation.sagemaker import SageMakerInstrumentor

SageMakerInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs SageMaker endpoint request bodies and responses to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-replicate 0.52.4
OpenTelemetry Replicate instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Replicate Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-replicate/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-replicate.svg">
</a>

This library allows tracing Replicate prompts and image generation sent with the official [replicate library](https://github.com/replicate/replicate-python).

## Installation

```bash
pip install opentelemetry-instrumentation-replicate
```

## Example usage

```python
from opentelemetry.instrumentation.replicate import ReplicateInstrumentor

ReplicateInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-qdrant 0.52.4
OpenTelemetry Qdrant instrumentation
Requires Python: <4,>=3.9

# OpenTelemetry Qdrant Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-qdrant/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-qdrant.svg">
</a>

This library allows tracing client-side calls to Qdrant vector DB sent with the official [Qdrant client library](https://github.com/qdrant/qdrant-client).

## Installation

```bash
pip install opentelemetry-instrumentation-qdrant
```

## Example usage

```python
from opentelemetry.instrumentation.qdrant import QdrantInstrumentor

QdrantInstrumentor().instrument()
```
opentelemetry-instrumentation-pinecone 0.52.4
OpenTelemetry Pinecone instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Pinecone Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-pinecone/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-pinecone.svg">
</a>

This library allows tracing client-side calls to Pinecone vector DB sent with the official [Pinecone library](https://github.com/pinecone-io/pinecone-python-client).

## Installation

```bash
pip install opentelemetry-instrumentation-pinecone
```

## Example usage

```python
from opentelemetry.instrumentation.pinecone import PineconeInstrumentor

PineconeInstrumentor().instrument()
```
opentelemetry-instrumentation-openai-agents 0.52.4
OpenTelemetry OpenAI Agents instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry OpenAI Agents Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-openai-agents/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-openai-agents.svg">
</a>

This library enables tracing of agentic workflows implemented using the [OpenAI Agents framework](https://github.com/openai/openai-agents-python), allowing visibility into agent reasoning, tool usage, and decision-making steps.

## Installation

```bash
pip install opentelemetry-instrumentation-openai-agents
```

## Example usage

```python
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor

OpenAIAgentsInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-openai 0.52.4
OpenTelemetry OpenAI instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry OpenAI Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-openai/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-openai.svg">
</a>

This library allows tracing OpenAI prompts and completions sent with the official [OpenAI library](https://github.com/openai/openai-python).

## Installation

```bash
pip install opentelemetry-instrumentation-openai
```

## Example usage

```python
from opentelemetry.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-ollama 0.52.4
OpenTelemetry Ollama instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Ollama Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-ollama/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-ollama.svg">
</a>

This library allows tracing calls to any of Ollama's endpoints sent with the official [Ollama Python Library](https://github.com/ollama/ollama-python).

## Installation

```bash
pip install opentelemetry-instrumentation-ollama
```

## Example usage

```python
from opentelemetry.instrumentation.ollama import OllamaInstrumentor

OllamaInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-mistralai 0.52.4
OpenTelemetry Mistral AI instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Mistral AI Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-mistralai/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-mistralai.svg">
</a>

This library allows tracing calls to any of mistralai's endpoints sent with the official [Mistral AI library](https://github.com/mistralai-ai/mistralai-python).

## Installation

```bash
pip install opentelemetry-instrumentation-mistralai
```

## Example usage

```python
from opentelemetry.instrumentation.mistralai import MistralAiInstrumentor

MistralAiInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-milvus 0.52.4
OpenTelemetry Milvus instrumentation
Requires Python: <4,>=3.9

# OpenTelemetry Milvus Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-milvus/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-milvus.svg">
</a>

This library allows tracing client-side calls to Milvus vector DB sent with the official [Milvus library](https://github.com/milvus-io/milvus).

## Installation

```bash
pip install opentelemetry-instrumentation-milvus
```

## Example usage

```python
from opentelemetry.instrumentation.milvus import MilvusInstrumentor

MilvusInstrumentor().instrument()
```
opentelemetry-instrumentation-mcp 0.52.4
OpenTelemetry mcp instrumentation
Requires Python: <4,>=3.10

OpenTelemetry MCP Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-mcp/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-mcp.svg">
</a>

This library allows tracing of agentic workflows implemented with MCP framework [mcp python sdk](https://github.com/modelcontextprotocol/python-sdk).

## Installation

```bash
pip install opentelemetry-instrumentation-mcp
```

## Example usage

```python
from opentelemetry.instrumentation.mcp import McpInstrumentor

McpInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application tool usage is working, and can make it easy to debug and evaluate the tool usage.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-marqo 0.52.4
OpenTelemetry Marqo instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Marqo Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-marqo/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-marqo.svg">
</a>

This library allows tracing client-side calls to Marqo vector DB sent with the official [Marqo library](https://github.com/marqo-ai/marqo).

## Installation

```bash
pip install opentelemetry-instrumentation-marqo
```

## Example usage

```python
from opentelemetry.instrumentation.marqo import MarqoInstrumentor

MarqoInstrumentor().instrument()
```
opentelemetry-instrumentation-llamaindex 0.52.4
OpenTelemetry LlamaIndex instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry LlamaIndex Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-llamaindex/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-llamaindex.svg">
</a>

This library allows tracing complete LLM applications built with [LlamaIndex](https://github.com/run-llama/llama_index).

## Installation

```bash
pip install opentelemetry-instrumentation-llamaindex
```

## Example usage

```python
from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor

LlamaIndexInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-langchain 0.52.4
OpenTelemetry Langchain instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry Langchain Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-langchain/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-langchain.svg">
</a>

This library allows tracing complete LLM applications built with [Langchain](https://github.com/langchain-ai/langchain).

## Installation

```bash
pip install opentelemetry-instrumentation-langchain
```

## Example usage

```python
from opentelemetry.instrumentation.langchain import LangchainInstrumentor

LangchainInstrumentor().instrument()
```

## Privacy

**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.

To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.

```bash
TRACELOOP_TRACE_CONTENT=false
```
opentelemetry-instrumentation-lancedb 0.52.4
OpenTelemetry Lancedb instrumentation
Requires Python: <4,>=3.10

# OpenTelemetry LanceDB Instrumentation

<a href="https://pypi.org/project/opentelemetry-instrumentation-lancedb/">
    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-lancedb.svg">
</a>

This library allows tracing client-side calls to LanceDB sent with the official [LanceDB library](https://github.com/lancedb/lancedb).

## Installation

```bash
pip install opentelemetry-instrumentation-lancedb
```

## Example usage

```python
from opentelemetry.instrumentation.lancedb import LanceInstrumentor

LanceInstrumentor().instrument()
```