semvec/pypi-packages huggingface dataset:
opentelemetry-if-instrumentation-vertexai 0.25.6
OpenTelemetry Vertex AI instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-transformers 0.25.6
OpenTelemetry transformers instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-together 0.25.6
OpenTelemetry Together AI instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-replicate 0.25.6
OpenTelemetry Replicate instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-qdrant 0.25.6
OpenTelemetry Qdrant instrumentation
License: Apache-2.0
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-if-instrumentation-pinecone 0.25.6
OpenTelemetry Pinecone instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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-if-instrumentation-openai 0.25.6
OpenTelemetry OpenAI instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-ollama 0.25.6
OpenTelemetry Ollama instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-milvus 0.25.6
OpenTelemetry Milvus instrumentation
License: Apache-2.0
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-if-instrumentation-marqo 0.25.6
OpenTelemetry Marqo instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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-if-instrumentation-llamaindex 0.25.6
OpenTelemetry LlamaIndex instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-langchain 0.25.6
OpenTelemetry Langchain instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# 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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-haystack 0.25.6
OpenTelemetry Haystack instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Haystack Instrumentation

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

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

## Installation

```bash
pip install opentelemetry-instrumentation-haystack
```

## Example usage

```python
from opentelemetry.instrumentation.haystack import HaystackInstrumentor

HaystackInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-google-generativeai 0.25.6
OpenTelemetry Google Generative AI instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Google Generative AI Instrumentation

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

This library allows tracing Google Gemini prompts and completions sent with the official [Google Generative AI library](https://github.com/google-gemini/generative-ai-python).

## Installation

```bash
pip install opentelemetry-instrumentation-google-generativeai
```

## Example usage

```python
from opentelemetry.instrumentation.google-generativeai import GoogleGenerativeAiInstrumentor

GoogleGenerativeAiInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-cohere 0.25.6
OpenTelemetry Cohere instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Cohere Instrumentation

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

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

## Installation

```bash
pip install opentelemetry-instrumentation-cohere
```

## Example usage

```python
from opentelemetry.instrumentation.cohere import CohereInstrumentor

CohereInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-chromadb 0.25.6
OpenTelemetry Chroma DB instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Chroma Instrumentation

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

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

## Installation

```bash
pip install opentelemetry-instrumentation-chromadb
```

## Example usage

```python
from opentelemetry.instrumentation.chromadb import ChromaInstrumentor

ChromaInstrumentor().instrument()
```
opentelemetry-if-instrumentation-bedrock 0.25.6
OpenTelemetry Bedrock instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Bedrock Instrumentation

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

This library allows tracing any of AWS Bedrock's models prompts and completions sent with [Boto3](https://github.com/boto/boto3) to Bedrock.

## Installation

```bash
pip install opentelemetry-instrumentation-bedrock
```

## Example usage

```python
from opentelemetry.instrumentation.bedrock import BedrockInstrumentor

BedrockInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-anthropic 0.25.6
OpenTelemetry Anthropic instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Anthropic Instrumentation

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

This library allows tracing Anthropic prompts and completions sent with the official [Anthropic library](https://github.com/anthropics/anthropic-sdk-python).

## Installation

```bash
pip install opentelemetry-instrumentation-anthropic
```

## Example usage

```python
from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor

AnthropicInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```
opentelemetry-if-instrumentation-alephalpha 0.25.6
OpenTelemetry Aleph Alpha instrumentation
License: Apache-2.0
Requires Python: <4,>=3.9

# OpenTelemetry Aleph Alpha Instrumentation

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

This library allows tracing calls to any of Aleph Alpha's endpoints sent with the official [Aleph Alpha Client](https://github.com/Aleph-Alpha/aleph-alpha-client).

## Installation

```bash
pip install opentelemetry-instrumentation-alephalpha
```

## Example usage

```python
from opentelemetry.instrumentation.alephalpha import AlephAlphaInstrumentor

AlephAlphaInstrumentor().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 `IFTRACER_TRACE_CONTENT` environment variable to `false`.

```bash
IFTRACER_TRACE_CONTENT=false
```