Skip to content

Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.

[Feat]: Update Docs with snippets, mermaid diagram and better images (#250)

patcher9c54b586cdc20
diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md
index 912899d1..aaa0efd2 100644
--- a/.github/ISSUE_TEMPLATE/bug.md
+++ b/.github/ISSUE_TEMPLATE/bug.md
@@ -8,20 +8,16 @@ assignees: ''
---
### πŸ› What's Going Wrong?
-Explain the bug. Tell us what's happening that shouldn't be.
+> Explain the bug. Tell us what's happening that shouldn't be.
### πŸ•΅οΈ Steps to Reproduce
-To see the bug, what should we do?
-1. Start at '...'
-2. Click '...'
-3. Look for '...'
-4. Oops, there's the issue!
+> To see the bug, what steps should we follow?
### 🎯 What Did You Expect?
-Describe what you thought would happen.
+> Describe what you thought would happen.
### πŸ“Έ Any Screenshots?
-Pictures can say a thousand words and can be super helpful!
+> Pictures can say a thousand words and can be super helpful!
### πŸ’» Your Setup
- OpenLIT Version: [e.g., 0.0.1]
@@ -29,7 +25,7 @@ Pictures can say a thousand words and can be super helpful!
- Deployment Method: [Helm, Docker]
### πŸ“ Additional Notes
-Got more to say? Tell us here.
+> Got more to say? Tell us here.
### πŸ‘ Want to Help Make It Happen?
- [ ] Yes, I'd like to volunteer and help out with this!
diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md
index 15c3f69a..84a2c379 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.md
+++ b/.github/ISSUE_TEMPLATE/feature-request.md
@@ -8,16 +8,16 @@ assignees: ''
---
### πŸš€ What's the Problem?
-Tell us what's not working right or what's getting in your way.
+> Tell us what's not working right or what's getting in your way.
### πŸ’‘ Your Dream Solution
-Tell us what you wish for, with as much detail as you like.
+> Tell us what you wish for, with as much detail as you like.
### πŸ€” Seen anything similar?
-Share other things you've tried or seen that are close to what you're thinking.
+> Share other things you've tried or seen that are close to what you're thinking.
### πŸ–ΌοΈ Pictures or Drawings
-Share any picture or drawing that shows your idea if you have.
+> Share any picture or drawing that shows your idea if you have.
### πŸ‘ Want to Help Make It Happen?
- [ ] Yes, I'd like to volunteer and help out with this!
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 1e58426b..396c4dfa 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,20 +1,19 @@
-#### Overview:
-What does this PR do? Link issues here.
+### Overview:
+> What does this PR do? Link issues here.
----
-#### Changes:
-- Key change 1
-- Key change 2
----
+### Changes:
+> Describe the changes and additional notes about your changes
-#### Visuals:
-Attach screenshots/screen recordings here to show the changes.
----
-#### Checklist:
+### Visuals:
+> Attach screenshots/screen recordings here to show the changes.
+
+
+
+### Checklist:
- [ ] PR name follows conventional commits format: `[Feat]: ...` or `[Fix]: ....`
- [ ] Added visuals for changes
- [ ] Checked OpenLIT [contribution guidelines](https://github.com/openlit/openlit/blob/main/CONTRIBUTING.md)
diff --git a/README.md b/README.md
index 747c8394..dd280836 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,6 @@ OpenTelemetry-native LLM Application Observability</h1>
[![GitHub Contributors](https://img.shields.io/github/contributors/openlit/openlit)](https://github.com/openlit/openlit/graphs/contributors)
[![Slack](https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=white)](https://join.slack.com/t/openlit/shared_invite/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ)
-[![Discord](https://img.shields.io/badge/Discord-7289DA?logo=discord&logoColor=white)](https://discord.gg/KxBBhmzG)
[![X](https://img.shields.io/badge/follow-%40OpenLIT-1DA1F2?logo=x&style=social)](https://twitter.com/openlit_io)
</div>
@@ -23,66 +22,111 @@ OpenLIT is an **OpenTelemetry-native** GenAI and LLM Application Observability t
This project proudly follows the [Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/tree/main/docs/gen-ai) of the OpenTelemetry community, consistently updating to align with the latest standards in observability.
## What is LIT?
-`LIT` stands for **Learning and Inference Tool**, which is a visual and interactive tool designed for understanding AI models and visualizing data. The term `LIT` was introduced by [Google](https://developers.google.com/machine-learning/glossary#learning-interpretability-tool-lit), although OpenLIT is not affiliated with Google.
+`LIT` stands for **Learning and Inference Tool**, which is a visual and interactive tool designed for understanding AI models and visualizing data. The term `LIT` was introduced by [Google](https://developers.google.com/machine-learning/glossary#learning-interpretability-tool-lit).
## ⚑ Features
-- **OpenTelemetry-native**: Native support ensures that integrating OpenLIT into your projects feels more like a natural extension rather than an additional layer of complexity.
-- **Granular Usage Insights of your LLM Applications**: Assess your LLM's performance and costs with fine-grained control, breaking down metrics by environment (such as staging or production) or application, to optimize for efficiency and scalability.
-- **Vendor-Neutral SDKs**: In the spirit of OpenTelemetry, OpenLIT's SDKs are agnostic of the backend vendors. This means you can confidently use OpenLIT with various telemetry backends, like Grafana Tempo, without worrying about compatibility issues.
+- **Advanced Monitoring of LLM and VectorDB Performance**: OpenLIT offers automatic instrumentation that generates traces and metrics, providing insights into the performance and costs of your LLM and VectorDB usage. This helps you analyze how your applications perform in different environments, such as production, enabling you to optimize resource ussage and scale efficiently.
+- **Cost Tracking for Custom and Fine-Tuned Models**: OpenLIT enables you to tailor cost tracking for specific models by using a custom JSON file. This feature allows for precise budgeting and ensures that cost estimations are perfectly aligned with your project needs.
+- **OpenTelemetry-native & vendor-neutral SDKs**: OpenLIT is built with native support for OpenTelemetry, making it blend seamlessly with your projects. This vendor-neutral approach reduces barriers to integration, making OpenLIT an intuitive part of your software stack rather than an additional complexity.
## πŸš€ Getting Started
-## Step 1: Deploy OpenLIT
-
-From the root directory of the this Repo, Run the below command:
-```shell
-docker-compose up -d
+```mermaid
+flowchart TB;
+ subgraph " "
+ direction LR;
+ subgraph " "
+ direction LR;
+ OpenLIT_SDK[OpenLIT SDK] -->|Sends Traces & Metrics| OTC[OpenTelemetry Collector];
+ OTC -->|Stores Data| ClickHouseDB[ClickHouse];
+ end
+ subgraph " "
+ direction RL;
+ OpenLIT_UI[OpenLIT UI] -->|Pulls Data| ClickHouseDB;
+ end
+ end
```
-## Step 2: Install OpenLIT SDK
+### Step 1: Deploy OpenLIT Stack
+
+1. Git Clone OpenLIT Repository
+ ```shell
+ git clone [email protected]:openlit/openlit.git
+ ```
+
+2. Start Docker Compose
+ ```shell
+ docker-compose up -d
+ ```
+
+### Step 2: Install OpenLIT SDK
+
+Open your command line or terminal and run:
```bash
pip install openlit
```
-### Step 2: Instrument your Application
-Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+### Step 3: Initialize OpenLIT in your Application
+Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **two lines of code**:
```python
import openlit
-openlit.init(otlp_endpoint="http://127.0.0.1:4318")
+openlit.init()
```
To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.
-> πŸ’‘ Info: If you dont provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, The SDK directs the trace directly to your console, which can be useful during development.
+> πŸ’‘ Info: If you dont provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, The OpenLIT SDK directs the trace directly to your console, which can be useful during development.
To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.
#### Example
-Here is how you can send telemetry from OpenLIT to Grafana Cloud
+---
-```python
-openlit.init(
- otlp_endpoint="https://otlp-gateway-prod-us-east-0.grafana.net/otlp",
- otlp_headers="Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-)
-```
+<details>
+ <summary>Initialize using Function Arguments</summary>
-Alternatively, You can also choose to set these values using `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` environment variables
+ Add the following two lines to your application code:
+
+ ```python
+ import openlit
+
+ openlit.init(
+ otlp_endpoint="http://127.0.0.1:4318",
+ )
+ ```
-```python
-openlit.init()
-```
+</details>
-```env
-export OTEL_EXPORTER_OTLP_ENDPOINT = "https://otlp-gateway-prod-us-east-0.grafana.net/otlp"
-export OTEL_EXPORTER_OTLP_HEADERS = "Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-```
+---
+
+<details>
+
+ ---
+
+ <summary>Initialize using Environment Variables</summary>
+
+ Add the following two lines to your application code:
+
+ ```python
+ import openlit
+
+ openlit.init()
+ ```
+
+ Then, configure the your OTLP endpoint using environment variable:
+
+ ```env
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "http://127.0.0.1:4318"
+ ```
+</details>
+
+---
-### Step 3: Visualize and Optimize!
+### Step 4: Visualize and Optimize!
With the LLM Observability data now being collected and sent to OpenLIT, the next step is to visualize and analyze this data to get insights into your LLM application's performance, behavior, and identify areas of improvement.
Just head over to OpenLIT UI at `127.0.0.1:3000` on your browser to start exploring. You can login using the default credentials
diff --git a/docs/latest/features/pricing.mdx b/docs/latest/features/pricing.mdx
index b7b6fd9a..6b097d0f 100644
--- a/docs/latest/features/pricing.mdx
+++ b/docs/latest/features/pricing.mdx
@@ -6,7 +6,7 @@ sidebarTitle: 'Track Cost for Custom Models'
OpenLIT provides built-in pricing information through a default pricing JSON file accessible from [this URL](https://raw.githubusercontent.com/openlit/openlit/main/assets/pricing.json). This default file, which is regularly updated to reflect the latest pricing from various LLM providers, covers a range of standard LLM usage scenarios and provides detailed pricing information.
-To support personalized pricing schemes for specialized needs, such as fine-tuned or custom models, OpenLIT allows users to specify their own pricing structure through a custom JSON file. This flexibility ensures that pricing calculations for LLM operations are accurately aligned with unique business models and specific application requirements.
+To support personalized pricing schemes for specialized needs, such as fine-tuned or custom models, OpenLIT allows users to specify their own pricing structure through a custom JSON file. This flexibility ensures that pricing calculations for LLM operations are accurately aligned with business and application requirements.
## Using the Default Pricing File
diff --git a/docs/latest/integrations/anthropic.mdx b/docs/latest/integrations/anthropic.mdx
index 883253fe..18ac95dd 100644
--- a/docs/latest/integrations/anthropic.mdx
+++ b/docs/latest/integrations/anthropic.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Anthropic'
<img src="/images/docs-anthropic-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Anthropic which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using Anthropic models. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Anthropic Python SDK client `>= 0.21.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/azure-openai.mdx b/docs/latest/integrations/azure-openai.mdx
index 681eb73e..82a2d0ca 100644
--- a/docs/latest/integrations/azure-openai.mdx
+++ b/docs/latest/integrations/azure-openai.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Azure OpenAI'
<img src="/images/docs-azure-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Azure OpenAI which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using Azure OpenAI models. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- OpenAI Python SDK client `>=1.13.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/bedrock.mdx b/docs/latest/integrations/bedrock.mdx
index 4da67c6f..0b5f901f 100644
--- a/docs/latest/integrations/bedrock.mdx
+++ b/docs/latest/integrations/bedrock.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Amazon Bedrock'
<img src="/images/docs-bedrock-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Bedrock which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using models from Amazon Bedrock. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Boto3 Python SDK client `>= 1.34.93`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/chromadb.mdx b/docs/latest/integrations/chromadb.mdx
index b84ab296..cde2222f 100644
--- a/docs/latest/integrations/chromadb.mdx
+++ b/docs/latest/integrations/chromadb.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'ChromaDB'
<img src="/images/docs-chromadb-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using ChromaDB which includes performance, Operation stats and more.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications using ChromaDB as the vector store. This includes tracking performance, operation stats and more.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- ChromaDB Python SDK client `>= 0.4.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/cohere.mdx b/docs/latest/integrations/cohere.mdx
index 1c77088b..bad5702e 100644
--- a/docs/latest/integrations/cohere.mdx
+++ b/docs/latest/integrations/cohere.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Cohere'
<img src="/images/docs-cohere-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Cohere which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using Cohere models. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Cohere Python SDK client `>= 5.3.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/groq.mdx b/docs/latest/integrations/groq.mdx
index bbdd2444..9bbf010e 100644
--- a/docs/latest/integrations/groq.mdx
+++ b/docs/latest/integrations/groq.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Groq'
<img src="/images/docs-groq-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Groq which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using models from Groq. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Groq Python SDK client `>= 0.5.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/haystack.mdx b/docs/latest/integrations/haystack.mdx
index 2b276f5e..efe98b16 100644
--- a/docs/latest/integrations/haystack.mdx
+++ b/docs/latest/integrations/haystack.mdx
@@ -7,37 +7,60 @@ sidebarTitle: 'Haystack'
<img src="/images/docs-haystack-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Haystack which includes performance and operation stats.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using Haystack. This includes tracking performance and operation stats.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -46,4 +69,7 @@ OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Appli
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/huggingface.mdx b/docs/latest/integrations/huggingface.mdx
index d588a5c4..18275019 100644
--- a/docs/latest/integrations/huggingface.mdx
+++ b/docs/latest/integrations/huggingface.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'HuggingFace'
<img src="/images/docs-huggingface-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using HuggingFace which includes performance, token usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using models from HuggingFace. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- HuggingFace Trasnformers Python SDK client `>= 4.39.3`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/langchain.mdx b/docs/latest/integrations/langchain.mdx
index 6acae985..9bece21f 100644
--- a/docs/latest/integrations/langchain.mdx
+++ b/docs/latest/integrations/langchain.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'LangChain'
<img src="/images/docs-langchain-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using LangChain which includes performance and operation stats.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using LangChain. This includes tracking performance and operation stats.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- LangChain Python SDK client `>= 0.1.1`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/litellm.mdx b/docs/latest/integrations/litellm.mdx
index 48a22999..61e15b64 100644
--- a/docs/latest/integrations/litellm.mdx
+++ b/docs/latest/integrations/litellm.mdx
@@ -7,37 +7,60 @@ sidebarTitle: 'LiteLLM'
<img src="/images/docs-litellm-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using LiteLLM which includes performance and operation stats.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using LiteLLM. This includes tracking performance and operation stats.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -46,4 +69,7 @@ OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Appli
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/llama-index.mdx b/docs/latest/integrations/llama-index.mdx
index 023e7597..c7018fdf 100644
--- a/docs/latest/integrations/llama-index.mdx
+++ b/docs/latest/integrations/llama-index.mdx
@@ -7,37 +7,60 @@ sidebarTitle: 'LlamaIndex'
<img src="/images/docs-llama-index-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using LlamaIndex which includes performance and operation stats.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using LlamaIndex. This includes tracking performance and operation stats.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -46,4 +69,7 @@ OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Appli
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/milvus.mdx b/docs/latest/integrations/milvus.mdx
index f9804570..b84b160e 100644
--- a/docs/latest/integrations/milvus.mdx
+++ b/docs/latest/integrations/milvus.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Milvus'
<img src="/images/docs-milvus-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Milvus which includes performance, Operation stats and more.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications using Milvus as the vector store. This includes tracking performance, operation stats and more.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Milvus Python SDK client `>= 2.4.3`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/mistral.mdx b/docs/latest/integrations/mistral.mdx
index 0835a165..eb28b5e5 100644
--- a/docs/latest/integrations/mistral.mdx
+++ b/docs/latest/integrations/mistral.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Mistral'
<img src="/images/docs-mistral-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Mistral which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using Mistral models. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Mistral Python SDK client `>= 0.1.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/ollama.mdx b/docs/latest/integrations/ollama.mdx
index a9b251dc..2c2942a2 100644
--- a/docs/latest/integrations/ollama.mdx
+++ b/docs/latest/integrations/ollama.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Ollama'
<img src="/images/docs-ollama-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Ollama which includes performance, token usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using models from Ollama. This includes tracking performance, token usage, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Ollama Python SDK client `>=0.2.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/openai.mdx b/docs/latest/integrations/openai.mdx
index fd4cab39..1e25803e 100644
--- a/docs/latest/integrations/openai.mdx
+++ b/docs/latest/integrations/openai.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'OpenAI'
<img src="/images/docs-openai-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using OpenAI which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using OpenAI models. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- OpenAI Python SDK client `>=1.13.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/pinecone.mdx b/docs/latest/integrations/pinecone.mdx
index 20213f91..eee4a555 100644
--- a/docs/latest/integrations/pinecone.mdx
+++ b/docs/latest/integrations/pinecone.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Pinecone'
<img src="/images/docs-pinecone-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Pinecone which includes performance, Operation stats and more.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications using Pinecone as the vector store. This includes tracking performance, operation stats and more.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- PineCone Python SDK client `>=2.2.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/qdrant.mdx b/docs/latest/integrations/qdrant.mdx
index 8ab334af..0c312f30 100644
--- a/docs/latest/integrations/qdrant.mdx
+++ b/docs/latest/integrations/qdrant.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Qdrant'
<img src="/images/docs-qdrant-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Qdrant which includes performance, Operation stats and more.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications using Qdrant as the vector store. This includes tracking performance, operation stats and more.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- Qdrant Python SDK client `>= 1.9.0`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/integrations/vertexai.mdx b/docs/latest/integrations/vertexai.mdx
index c416fd10..7973c736 100644
--- a/docs/latest/integrations/vertexai.mdx
+++ b/docs/latest/integrations/vertexai.mdx
@@ -7,7 +7,9 @@ sidebarTitle: 'Vertex AI'
<img src="/images/docs-vertexai-banner.gif" />
</Frame>
-OpenLIT SDKs provide OpenTelemetry Auto-Instrumentation for monitoring LLM Application using Vertex AI which includes performance, token and cost usage and user interactions.
+OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built using models from Vertex AI. This includes tracking performance, token usage, costs, and how users interact with the application.
+
+Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding the OpenLIT in your application, all the necessary monitoring configurations are automatically set up.
The integration is compatible with
- google-cloud-aiplatform `>= 1.38.1`
@@ -15,32 +17,53 @@ The integration is compatible with
## Get Started
<Steps>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install OpenLIT">
+ Open your command line or terminal and run:
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+ <Step title="Initialize OpenLIT in your Application">
+ You can set up the OpenLIT in your application using either function arguments directly in your code or by using environment variables.
+ <Tabs>
+ <Tab title="Setup using function arguments">
+
+ Add the following two lines to your application code:
```python
import openlit
- openlit.init(otlp_endpoint="otlp_backend_endpoint", otlp_headers="otlp_backend_token")
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ )
```
- Alternatively, you can configure the OTLP endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` and the OTLP headers by setting the Appli`OTEL_EXPORTER_OTLP_HEADERS` environmentcation variable as recommended in the OpenTelemetry documentation.
-
- If your aim is primarily to test or develop without sending telemetry data to an external backend, you can initialize OpenLIT without any parameters. This approach directs all telemetry output to your console, enabling quick diagnostics and local debugging:
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ <Tab title="Setup using Environment Variables">
+ Add the following two lines to your application code:
+
```python
import openlit
openlit.init()
```
-
- Refer to the OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
- </Step>
+
+ Then, configure the your OTLP endpoint using environment variable:
+ ```shell
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ ```
+
+ Replace:
+ 1. `YOUR_OTEL_ENDPOINT` with the URL of your OpenTelemetry backend, such as `http://127.0.0.1:4318` if you are using OpenLIT and a local OTel Collector.
+ </Tab>
+ </Tabs>
+ To send metrics and traces to other Observability tools, refer to the [Connections Guide](/latest/connections/intro).
+
+ For more advanced configurations and application use cases, visit the [OpenLIT Python repository](https://github.com/openlit/openlit/tree/main/sdk/python).
+ </Step>
</Steps>
---
@@ -49,4 +72,7 @@ The integration is compatible with
<Card title="Connections" href="/latest/connections/intro" icon='link'>
Connect to your existing Observablity Stack
</Card>
+<Card title="SDK configuration" href="/latest/sdk-configuration" icon='file-code'>
+Documentation of the configuration options for the OpenLIT SDK.
+</Card>
</CardGroup>
\ No newline at end of file
diff --git a/docs/latest/introduction.mdx b/docs/latest/introduction.mdx
index a9717aa3..f2610e0a 100644
--- a/docs/latest/introduction.mdx
+++ b/docs/latest/introduction.mdx
@@ -12,16 +12,15 @@ OpenLIT is an **OpenTelemetry-native** GenAI and LLM Application Observability t
This project proudly follows the [Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/tree/main/docs/gen-ai) of the OpenTelemetry community, consistently updating to align with the latest standards in observability.
## What is LIT?
-LIT stands for Learning Interpretability Tool. It refers to a visual, interactive model-understanding and data visualization tool ad a term introduced by [Google](https://developers.google.com/machine-learning/glossary#learning-interpretability-tool-lit).
+`LIT` stands for **Learning and Inference Tool**, which is a visual and interactive tool designed for understanding AI models and visualizing data.
+The term `LIT` was introduced by [Google](https://developers.google.com/machine-learning/glossary#learning-interpretability-tool-lit).
## ⚑ Features
-<Frame>
- <img src="/images/docs-ui-banner.jpeg" />
-</Frame>
+![OpenLIT Connections Banner](https://github.com/openlit/.github/blob/main/profile/assets/github-readme-connections-banner.png?raw=true)
-- **OpenTelemetry-native**: Native support ensures that integrating OpenLIT into your projects feels more like a natural extension rather than an additional layer of complexity.
-- **Granular Usage Insights of your LLM Applications**: Assess your LLM's performance and costs with fine-grained control, breaking down metrics by environment (such as staging or production) or application, to optimize for efficiency and scalability.
-- **Vendor-Neutral SDKs**: In the spirit of OpenTelemetry, OpenLIT's SDKs are agnostic of the backend vendors. This means you can confidently use OpenLIT with various telemetry backends, like Grafana Tempo, without worrying about compatibility issues.
+- **Advanced Monitoring of LLM and VectorDB Performance**: OpenLIT offers automatic instrumentation that generates traces and metrics, providing insights into the performance and costs of your LLM and VectorDB usage. This helps you analyze how your applications perform in different environments, such as production, enabling you to optimize resource ussage and scale efficiently.
+- **Cost Tracking for Custom and Fine-Tuned Models**: OpenLIT enables you to tailor cost tracking for specific models by using a custom JSON file. This feature allows for precise budgeting and ensures that cost estimations are perfectly aligned with your project needs.
+- **OpenTelemetry-native & vendor-neutral SDKs**: OpenLIT is built with native support for OpenTelemetry, making it blend seamlessly with your projects. This vendor-neutral approach reduces barriers to integration, making OpenLIT an intuitive part of your software stack rather than an additional complexity.
## Getting Started
Select from the following guides to learn more about how to use OpenLIT:
diff --git a/docs/latest/quickstart.mdx b/docs/latest/quickstart.mdx
index e933fb72..e9dfb329 100644
--- a/docs/latest/quickstart.mdx
+++ b/docs/latest/quickstart.mdx
@@ -7,8 +7,24 @@ icon: 'bolt'
This guide will walk you through setting up OpenTelemetry Auto Instrumentation for monitoring your LLM Application using OpenLIT. In just a few steps, you'll be able to track and analyze the performance and usage of your LLM Applications.
In this guide, we'll show how you can send OpenTelemetry traces and metrics from your LLM Applications to Grafana Cloud
+```mermaid
+flowchart TB;
+ subgraph " "
+ direction LR;
+ subgraph " "
+ direction LR;
+ OpenLIT_SDK[OpenLIT SDK] -->|Sends Traces & Metrics| OTC[OpenTelemetry Collector];
+ OTC -->|Stores Data| ClickHouseDB[ClickHouse];
+ end
+ subgraph " "
+ direction RL;
+ OpenLIT_UI[OpenLIT UI] -->|Pulls Data| ClickHouseDB;
+ end
+ end
+```
+
<Steps>
- <Step title="Deploy OpenLIT">
+ <Step title="Deploy OpenLIT UI">
<Steps>
<Step title="Git Clone OpenLIT Repository">
```shell
@@ -23,13 +39,13 @@ In this guide, we'll show how you can send OpenTelemetry traces and metrics from
</Step>
</Steps>
</Step>
- <Step title="Install the OpenLIT Python SDK using pip">
+ <Step title="Install the OpenLIT SDK">
```shell
pip install openlit
```
</Step>
- <Step title="Add the following two lines to your application code:">
- Add the snippet below to your Python application.
+ <Step title="Initialize the OpenLIT in Your Application">
+ Add the following two lines to your application code:
<Tabs>
<Tab title="Setup using function arguments">
```python
@@ -62,6 +78,8 @@ In this guide, we'll show how you can send OpenTelemetry traces and metrics from
```
</Tab>
<Tab title="Setup using Environment Variables">
+
+ Add the following two lines to your application code:
```python
import openlit
diff --git a/docs/latest/sdk-configuration.mdx b/docs/latest/sdk-configuration.mdx
index 061f25be..6032f413 100644
--- a/docs/latest/sdk-configuration.mdx
+++ b/docs/latest/sdk-configuration.mdx
@@ -6,16 +6,16 @@ icon: 'file-code'
Below is a detailed overview of the configuration options available, allowing you to adjust OpenLIT's behavior and functionality to align with your specific observability needs:
-| Argument | Description | Default Value | Required |
-|-------------------------|-----------------------------------------------------------------------------------------------|----------------|----------|
-| `environment` | The deployment environment of the application. | `"default"` | Yes |
-| `application_name` | Identifies the name of your application. | `"default"` | Yes |
-| `tracer` | An instance of OpenTelemetry Tracer for tracing operations. | `None` | No |
-| `meter` | An OpenTelemetry Metrics instance for capturing metrics. | `None` | No |
-| `otlp_endpoint` | Specifies the OTLP endpoint for transmitting telemetry data. | `None` | No |
-| `otlp_headers` | Defines headers for the OTLP exporter, useful for backends requiring authentication. | `None` | No |
-| `disable_batch` | A flag to disable batch span processing, favoring immediate dispatch. | `False` | No |
-| `trace_content` | Enables tracing of content for deeper insights. | `True` | No |
-| `disabled_instrumentors`| List of instrumentors to disable. Choices: `["openai", "anthropic", "langchain", "cohere", "mistral", "transformers", "chroma", "pinecone"]`. | `None` | No |
-| `disable_metrics` | If set, disables the collection of metrics. | `False` | No |
-| `pricing_json` | URL or file path of the pricing JSON file. | `https://github.com/openlit/openlit/blob/main/assets/pricing.json` | No |
\ No newline at end of file
+| Argument | Description | Default Value |
+|-------------------------|-----------------------------------------------------------------------------------------------|----------------|
+| `environment` | The deployment environment of the application. | `"default"` |
+| `application_name` | Identifies the name of your application. | `"default"` |
+| `tracer` | An instance of OpenTelemetry Tracer for tracing operations. | `None` |
+| `meter` | An OpenTelemetry Metrics instance for capturing metrics. | `None` |
+| `otlp_endpoint` | Specifies the OTLP endpoint for transmitting telemetry data. | `None` |
+| `otlp_headers` | Defines headers for the OTLP exporter, useful for backends requiring authentication. | `None` |
+| `disable_batch` | A flag to disable batch span processing, favoring immediate dispatch. | `False` |
+| `trace_content` | Enables tracing of content for deeper insights. | `True` |
+| `disabled_instrumentors`| List of instrumentors to disable. | `None` |
+| `disable_metrics` | If set, disables the collection of metrics. | `False` |
+| `pricing_json` | URL or file path of the pricing JSON file. | `https://github.com/openlit/openlit/blob/main/assets/pricing.json` |
\ No newline at end of file
diff --git a/sdk/python/README.md b/sdk/python/README.md
index 90a41e64..a85fb15f 100644
--- a/sdk/python/README.md
+++ b/sdk/python/README.md
@@ -13,6 +13,9 @@ OpenTelemetry Auto-Instrumentation for GenAI & LLM Applications</h1>
[![Slack](https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=white)](https://join.slack.com/t/openlit/shared_invite/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ)
[![X](https://img.shields.io/badge/follow-%40OpenLIT-1DA1F2?logo=x&style=social)](https://twitter.com/openlit_io)
+![OpenLIT Connections Banner](https://github.com/openlit/.github/blob/main/profile/assets/github-readme-connections-banner.png?raw=true)
+
+
</div>
OpenLIT Python SDK is an **OpenTelemetry-native** Auto instrumentation library for monitoring LLM Applications, facilitating the integration of observability into your GenAI-driven projects. Designed with simplicity and efficiency, OpenLIT offers the ability to embed observability into your GenAI-driven projects effortlessly using just **a single line of code**.
@@ -21,31 +24,20 @@ Whether you're directly using LLM Libraries like OpenAI, Anthropic or building c
This project adheres to the [Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/tree/main/docs/gen-ai) proposed by the OpenTelemetry community. You can check out the current definitions [here](src/openlit/semcov/__init__.py).
-## What can be Auto Instrumented?
-
-### LLMs
-- [βœ… OpenAI](https://docs.openlit.io/latest/integrations/openai)
-- [βœ… Ollama](https://docs.openlit.io/latest/integrations/ollama)
-- [βœ… Anthropic](https://docs.openlit.io/latest/integrations/anthropic)
-- [βœ… Cohere](https://docs.openlit.io/latest/integrations/cohere)
-- [βœ… Mistral](https://docs.openlit.io/latest/integrations/mistral)
-- [βœ… Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai)
-- [βœ… HuggingFace Transformers](https://docs.openlit.io/latest/integrations/huggingface)
-- [βœ… Amazon Bedrock](https://docs.openlit.io/latest/integrations/bedrock)
-- [βœ… Vertex AI](https://docs.openlit.io/latest/integrations/vertexai)
-- [βœ… Groq](https://docs.openlit.io/latest/integrations/groq)
-
-### Vector DBs
-- [βœ… ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)
-- [βœ… Pinecone](https://docs.openlit.io/latest/integrations/pinecone)
-- [βœ… Qdrant](https://docs.openlit.io/latest/integrations/qdrant)
-- [βœ… Milvus](https://docs.openlit.io/latest/integrations/milvus)
-
-### Frameworks
-- [βœ… Langchain](https://docs.openlit.io/latest/integrations/langchain)
-- [βœ… LiteLLM](https://docs.openlit.io/latest/integrations/litellm)
-- [βœ… LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index)
-- [βœ… Haystack](https://docs.openlit.io/latest/integrations/haystack)
+## Auto Instrumentation Capabilities
+
+| LLMs | Vector DBs | Frameworks |
+|----------------------------------------------------------|----------------------------------------------|----------------------------------------------|
+| [βœ… OpenAI](https://docs.openlit.io/latest/integrations/openai) | [βœ… ChromaDB](https://docs.openlit.io/latest/integrations/chromadb) | [βœ… Langchain](https://docs.openlit.io/latest/integrations/langchain) |
+| [βœ… Ollama](https://docs.openlit.io/latest/integrations/ollama) | [βœ… Pinecone](https://docs.openlit.io/latest/integrations/pinecone) | [βœ… LiteLLM](https://docs.openlit.io/latest/integrations/litellm) |
+| [βœ… Anthropic](https://docs.openlit.io/latest/integrations/anthropic) | [βœ… Qdrant](https://docs.openlit.io/latest/integrations/qdrant) | [βœ… LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index) |
+| [βœ… Cohere](https://docs.openlit.io/latest/integrations/cohere) | [βœ… Milvus](https://docs.openlit.io/latest/integrations/milvus) | [βœ… Haystack](https://docs.openlit.io/latest/integrations/haystack) |
+| [βœ… Mistral](https://docs.openlit.io/latest/integrations/mistral) | |
+| [βœ… Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai) | |
+| [βœ… HuggingFace Transformers](https://docs.openlit.io/latest/integrations/huggingface) | |
+| [βœ… Amazon Bedrock](https://docs.openlit.io/latest/integrations/bedrock) | |
+| [βœ… Vertex AI](https://docs.openlit.io/latest/integrations/vertexai) | |
+| [βœ… Groq](https://docs.openlit.io/latest/integrations/groq) | |
## Supported Destinations
- [βœ… OpenTelemetry Collector](https://docs.openlit.io/latest/connections/otelcol)
@@ -67,14 +59,16 @@ pip install openlit
## πŸš€ Getting Started
-## Step 1: Install OpenLIT SDK
+### Step 1: Install OpenLIT
+
+Open your command line or terminal and run:
```bash
pip install openlit
```
-### Step 2: Instrument your Application
-Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**:
+### Step 2: Initialize OpenLIT in your Application
+Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **two lines of code**:
```python
import openlit
@@ -82,46 +76,68 @@ import openlit
openlit.init()
```
-By default, OpenLIT directs traces and metrics straight to your console. To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.
+To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.
+
+> πŸ’‘ Info: If you dont provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, OpenLIT directs the trace directly to your console, which can be useful during development.
To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.
#### Example
-Here is how you can send telemetry from OpenLIT to Grafana Cloud
+---
-```python
-openlit.init(
- otlp_endpoint="https://otlp-gateway-prod-us-east-0.grafana.net/otlp",
- otlp_headers="Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-)
-```
+<details>
+ <summary>Initialize using Function Arguments</summary>
+
+ ---
-Alternatively, You can also choose to set these values using `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` environment variables
+ Add the following two lines to your application code:
+
+ ```python
+ import openlit
+
+ openlit.init(
+ otlp_endpoint="YOUR_OTEL_ENDPOINT",
+ otlp_headers ="YOUR_OTEL_ENDPOINT_AUTH"
+ )
+ ```
-```python
-openlit.init()
-```
+</details>
-```env
-export OTEL_EXPORTER_OTLP_ENDPOINT = "https://otlp-gateway-prod-us-east-0.grafana.net/otlp"
-export OTEL_EXPORTER_OTLP_HEADERS = "Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-```
+---
+
+<details>
+
+ <summary>Initialize using Environment Variables</summary>
+
+ ---
+
+ Add the following two lines to your application code:
+
+ ```python
+ import openlit
+
+ openlit.init()
+ ```
+
+ Then, configure the your OTLP endpoint using environment variable:
+
+ ```env
+ export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+ export OTEL_EXPORTER_OTLP_HEADERS = "YOUR_OTEL_ENDPOINT_AUTH"
+ ```
+</details>
+
+---
### Step 3: Visualize and Optimize!
-With the LLM Observability data now being collected and sent to your chosen OpenTelemetry backend, the next step is to visualize and analyze this data to glean insights into your application's performance, behavior, and identify areas of improvement. Here is how you would use the data in Grafana, follow these detailed instructions to explore your LLM application's Telemetry data.
+With the LLM Observability data now being collected and sent to OpenLIT, the next step is to visualize and analyze this data to get insights into your LLM application’s performance, behavior, and identify areas of improvement.
- - Select the **Explore** option from Grafana's sidebar.
- - At the top, ensure the correct Tempo data source is selected from the dropdown menu.
- - Use the **Query** field to specify any particular traces you are interested in, or leave it empty to browse through all the available traces.
- - You can adjust the time range to focus on specific periods of interest.
- - Hit **Run Query** to fetch your trace data. You'll see a visual representation of your traces along with detailed information on particular spans when clicked.
+To begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart).
-#### Next Steps
+If you want to integrate and send metrics and traces to your existing observability tools, refer to our [Connections Guide](https://docs.openlit.io/latest/connections/intro) for detailed instructions.
-- **Create Dashboards:** Beyond just exploring traces, consider creating dashboards in Grafana to monitor key performance indicators (KPIs) and metrics over time. Dashboards can be customized with various panels to display graphs, logs, and single stats that are most relevant to your application's performance and usage patterns.
-- **Set Alerts:** Grafana also allows you to set up alerts based on specific thresholds. This feature can be invaluable in proactively managing your application's health by notifying you of potential issues before they impact users.
-- **Iterate and Optimize:** Use the insights gained from your observability data to make informed decisions on optimizing your LLM application. This might involve refining model parameters, adjusting scaling strategies, or identifying and resolving bottlenecks.
+![](https://github.com/openlit/.github/blob/main/profile/assets/openlit-client-1.png?raw=true)
### Configuration
@@ -138,7 +154,7 @@ Below is a detailed overview of the configuration options available, allowing yo
| `otlp_headers` | Defines headers for the OTLP exporter, useful for backends requiring authentication. | `None` | No |
| `disable_batch` | A flag to disable batch span processing, favoring immediate dispatch. | `False` | No |
| `trace_content` | Enables tracing of content for deeper insights. | `True` | No |
-| `disabled_instrumentors`| List of instrumentors to disable. Choices: `["openai", "anthropic", "langchain", "cohere", "mistral", "transformers", "chroma", "pinecone"]`. | `None` | No |
+| `disabled_instrumentors`| List of instrumentors to disable. | `None` | No |
| `disable_metrics` | If set, disables the collection of metrics. | `False` | No |
| `pricing_json` | URL or file path of the pricing JSON file. | `https://github.com/openlit/openlit/blob/main/assets/pricing.json` | No |
diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.toml
index 5f539fdd..dc23bcf7 100644
--- a/sdk/python/pyproject.toml
+++ b/sdk/python/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "openlit"
-version = "1.8.0"
+version = "1.9.0"
description = "OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications, facilitating the integration of observability into your GenAI-driven projects"
authors = ["OpenLIT"]
repository = "https://github.com/openlit/openlit/tree/main/openlit/python"
diff --git a/sdk/python/src/openlit/instrumentation/cohere/cohere.py b/sdk/python/src/openlit/instrumentation/cohere/cohere.py
index a2740da8..204fae27 100644
--- a/sdk/python/src/openlit/instrumentation/cohere/cohere.py
+++ b/sdk/python/src/openlit/instrumentation/cohere/cohere.py
@@ -203,9 +203,9 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
False)
span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_ID,
- response.response_id)
+ response.generation_id)
span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
- response.response_id)
+ response.finish_reason)
span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
response.meta.billed_units.input_tokens)
span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
@@ -306,10 +306,11 @@ def chat_stream(gen_ai_endpoint, version, environment, application_name,
# Collect message IDs and aggregated response from events
if event.event_type == "stream-end":
llmresponse = event.response.text
- response_id = event.response.response_id
prompt_tokens = event.response.meta.billed_units.input_tokens
completion_tokens = event.response.meta.billed_units.output_tokens
finish_reason = event.finish_reason
+ if event.event_type == "stream-start":
+ response_id = event.generation_id
yield event
# Handling exception ensure observability without disrupting operation
diff --git a/sdk/python/tests/test_cohere.py b/sdk/python/tests/test_cohere.py
index 2a92bba4..899d68a0 100644
--- a/sdk/python/tests/test_cohere.py
+++ b/sdk/python/tests/test_cohere.py
@@ -56,7 +56,7 @@ def test_chat():
message='Say this is a test',
model='command'
)
- assert chat_resp.response_id is not None
+ assert chat_resp.generation_id is not None
except cohere.core.api_error.ApiError as e:
print("Rate Limited:", e)