langtrace-python-sdk 1.2.23__tar.gz → 1.3.1__tar.gz

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 1.2.23
+Version: 1.3.1
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -72,6 +72,68 @@ from langtrace_python_sdk import langtrace # Must precede any llm module imports
 langtrace.init() # LANGTRACE_API_KEY as an ENVIRONMENT variable
 ```
 
+## FastAPI Quick Start
+Initialize FastAPI project and add this inside the ```main.py``` file
+
+```python
+from fastapi import FastAPI
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+langtrace.init()
+app = FastAPI()
+client = OpenAI()
+
+@app.get("/")
+def root():
+    client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=False,
+    )
+    return {"Hello": "World"}
+```
+
+## Django Quick Start
+Initialize django project and add this inside the ```__init.py__``` file
+```python
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+
+langtrace.init()
+client = OpenAI()
+
+client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Say this is a test three times"}],
+    stream=False,
+)
+
+```
+
+## Flask Quick Start
+Initialize flask project and this inside ```app.py``` file
+```python
+from flask import Flask
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+langtrace.init()
+client = OpenAI()
+app = Flask(__name__)
+
+
+@app.route("/")
+def main():
+    client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=False,
+    )
+    return "Hello, World!"
+```
+
 ## Langtrace Self Hosted
 
 Get started by adding simply two lines to your code and see traces being logged to the console!
@@ -158,6 +220,7 @@ Langtrace automatically captures traces from the following vendors:
 | ------ | ------ | ------ | ------ |
 | OpenAI | LLM | :white_check_mark: | :white_check_mark: |
 | Anthropic | LLM | :white_check_mark: | :white_check_mark: |
+| Cohere | LLM | :x: | :white_check_mark: |
 | Azure OpenAI | LLM | :white_check_mark: | :white_check_mark: |
 | Langchain | Framework | :x: | :white_check_mark: |
 | LlamaIndex | Framework | :white_check_mark: | :white_check_mark: |

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/README.md

@@ -44,6 +44,68 @@ from langtrace_python_sdk import langtrace # Must precede any llm module imports
 langtrace.init() # LANGTRACE_API_KEY as an ENVIRONMENT variable
 ```
 
+## FastAPI Quick Start
+Initialize FastAPI project and add this inside the ```main.py``` file
+
+```python
+from fastapi import FastAPI
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+langtrace.init()
+app = FastAPI()
+client = OpenAI()
+
+@app.get("/")
+def root():
+    client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=False,
+    )
+    return {"Hello": "World"}
+```
+
+## Django Quick Start
+Initialize django project and add this inside the ```__init.py__``` file
+```python
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+
+langtrace.init()
+client = OpenAI()
+
+client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Say this is a test three times"}],
+    stream=False,
+)
+
+```
+
+## Flask Quick Start
+Initialize flask project and this inside ```app.py``` file
+```python
+from flask import Flask
+from langtrace_python_sdk import langtrace
+from openai import OpenAI
+
+langtrace.init()
+client = OpenAI()
+app = Flask(__name__)
+
+
+@app.route("/")
+def main():
+    client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=False,
+    )
+    return "Hello, World!"
+```
+
 ## Langtrace Self Hosted
 
 Get started by adding simply two lines to your code and see traces being logged to the console!
@@ -130,6 +192,7 @@ Langtrace automatically captures traces from the following vendors:
 | ------ | ------ | ------ | ------ |
 | OpenAI | LLM | :white_check_mark: | :white_check_mark: |
 | Anthropic | LLM | :white_check_mark: | :white_check_mark: |
+| Cohere | LLM | :x: | :white_check_mark: |
 | Azure OpenAI | LLM | :white_check_mark: | :white_check_mark: |
 | Langchain | Framework | :x: | :white_check_mark: |
 | LlamaIndex | Framework | :white_check_mark: | :white_check_mark: |

langtrace_python_sdk-1.3.1/src/examples/cohere_example/chat.py

@@ -0,0 +1,26 @@
+from dotenv import find_dotenv, load_dotenv
+import cohere
+
+from langtrace_python_sdk import langtrace
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(batch=False, debug_log_to_console=True, write_to_langtrace_cloud=False)
+
+co = cohere.Client()
+
+
+# @with_langtrace_root_span("chat_create")
+def chat_comp():
+    response = co.chat(
+        chat_history=[
+            {"role": "USER", "message": "Who discovered gravity?"},
+            {"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
+        ],
+        message="What is today's news?",
+        # preamble="answer like yoda",
+        # perform web search before answering the question. You can also use your own custom connector.
+        # connectors=[{"id": "web-search"}]
+    )
+    print(response)

langtrace_python_sdk-1.3.1/src/examples/cohere_example/chat_stream.py

@@ -0,0 +1,23 @@
+from dotenv import find_dotenv, load_dotenv
+import cohere
+
+from langtrace_python_sdk import langtrace
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(batch=False, debug_log_to_console=True, write_to_langtrace_cloud=False)
+
+co = cohere.Client()
+
+
+# @with_langtrace_root_span("chat_stream")
+def chat_stream():
+    result = []
+    for event in co.chat_stream(message="Tell me a short story in 2 lines"):
+        if event.event_type == "text-generation":
+            result.append(event.text)
+        elif event.event_type == "stream-end":
+            break
+    print("".join(result))
+    return result

langtrace_python_sdk-1.3.1/src/examples/cohere_example/embed_create.py

@@ -0,0 +1,21 @@
+from dotenv import find_dotenv, load_dotenv
+import cohere
+
+from langtrace_python_sdk import langtrace
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(batch=False, debug_log_to_console=True, write_to_langtrace_cloud=False)
+
+co = cohere.Client()
+
+
+# @with_langtrace_root_span("embed_create")
+def embed_create():
+    response = co.embed(
+        texts=['hello', 'goodbye'],
+        model='embed-english-v3.0',
+        input_type='classification'
+    )
+    # print(response)

langtrace_python_sdk-1.3.1/src/examples/fastapi_example/basic_route.py

@@ -0,0 +1,38 @@
+from fastapi import FastAPI
+from langchain_community.vectorstores.faiss import FAISS
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts.chat import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from openai import OpenAI
+
+from langtrace_python_sdk import langtrace
+
+langtrace.init(write_to_langtrace_cloud=False, debug_log_to_console=True)
+app = FastAPI()
+client = OpenAI()
+
+@app.get("/")
+def root():
+    vectorstore = FAISS.from_texts(
+        ["Langtrace helps you ship high quality AI Apps to production."], embedding=OpenAIEmbeddings()
+    )
+    retriever = vectorstore.as_retriever()
+
+    template = """Answer the question based only on the following context:{context}
+
+        Question: {question}
+    """
+    prompt = ChatPromptTemplate.from_template(template)
+
+    model = ChatOpenAI()
+
+    chain = (
+        {"context": retriever, "question": RunnablePassthrough()}
+        | prompt
+        | model
+        | StrOutputParser()
+    )
+
+    res = chain.invoke("How is Langtrace useful?")
+    return {"response": res}

langtrace_python_sdk-1.3.1/src/examples/perplexity_example/basic.py

@@ -0,0 +1,21 @@
+from openai import OpenAI
+
+from langtrace_python_sdk import langtrace
+from langtrace_python_sdk.utils.with_root_span import (
+    with_additional_attributes, with_langtrace_root_span)
+
+# _ = load_dotenv(find_dotenv())
+
+langtrace.init(batch=False, write_to_langtrace_cloud=False, debug_log_to_console=True)
+client = OpenAI(base_url="https://api.perplexity.ai", api_key="PPLX_API_KEY")
+
+
+@with_additional_attributes({"user.id": "1234", "user.feedback.rating": 1})
+def basic():
+    response = client.chat.completions.create(
+        model="pplx-70b-online",
+        messages=[{"role": "user", "content": "What is the capital of France?"}],
+        stream=False,
+    )
+    print(response)
+    return response

langtrace_python_sdk-1.3.1/src/langtrace_python_sdk/constants/instrumentation/cohere.py

@@ -0,0 +1,17 @@
+APIS = {
+    "CHAT_CREATE": {
+        "URL": "https://api.cohere.ai",
+        "METHOD": "cohere.client.chat",
+        "ENDPOINT": "/v1/chat",
+    },
+    "EMBED_CREATE": {
+        "URL": "https://api.cohere.ai",
+        "METHOD": "cohere.client.embed",
+        "ENDPOINT": "/v1/embed",
+    },
+    "CHAT_STREAM": {
+        "URL": "https://api.cohere.ai",
+        "METHOD": "cohere.client.chat_stream",
+        "ENDPOINT": "/v1/messages",
+    },
+}

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/src/langtrace_python_sdk/constants/instrumentation/common.py

@@ -16,6 +16,8 @@ SERVICE_PROVIDERS = {
     "LLAMAINDEX": "LlamaIndex",
     "OPENAI": "OpenAI",
     "PINECONE": "Pinecone",
+    "COHERE": "Cohere",
+    "PPLX": "Perplexity",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk-1.3.1/src/langtrace_python_sdk/instrumentation/cohere/instrumentation.py

@@ -0,0 +1,53 @@
+"""
+Instrumentation for Cohere
+"""
+
+import importlib.metadata
+from typing import Collection
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
+from langtrace_python_sdk.instrumentation.cohere.patch import (
+    chat_create,
+    chat_stream,
+    embed_create
+)
+
+class CohereInstrumentation(BaseInstrumentor):
+    """
+    The CohereInstrumentation class represents the Anthropic instrumentation
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["cohere >= 5.0.0"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("cohere")
+
+        wrap_function_wrapper(
+            "cohere.client",
+            "Client.chat",
+            chat_create("cohere.client.chat", version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "cohere.client",
+            "Client.chat_stream",
+            chat_stream("cohere.client.chat_stream", version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "cohere.client",
+            "Client.embed",
+            embed_create("cohere.client.embed", version, tracer),
+        )
+
+    def _instrument_module(self, module_name):
+        pass
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk-1.3.1/src/langtrace_python_sdk/instrumentation/cohere/patch.py

@@ -0,0 +1,370 @@
+"""
+This module contains the patching logic for the Anthropic library."""
+
+import json
+
+from langtrace.trace_attributes import Event, LLMSpanAttributes
+from opentelemetry import baggage
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+
+from langtrace_python_sdk.constants.instrumentation.cohere import APIS
+from langtrace_python_sdk.constants.instrumentation.common import (LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+from langtrace_python_sdk.utils.llm import estimate_tokens
+
+
+def embed_create(original_method, version, tracer):
+    """Wrap the `embed_create` method."""
+
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["COHERE"]
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": APIS["EMBED_CREATE"]["URL"],
+            "llm.api": APIS["EMBED_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get("model"),
+            "llm.prompts": "",
+            "llm.embedding_dataset_id": kwargs.get("dataset_id"),
+            "llm.embedding_input_type": kwargs.get("input_type"),
+            "llm.embedding_job_name": kwargs.get("name"),
+            **(extra_attributes if extra_attributes is not None else {})
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        if kwargs.get("user") is not None:
+            attributes.llm_user = kwargs.get("user")
+
+        span = tracer.start_span(
+            APIS["EMBED_CREATE"]["METHOD"], kind=SpanKind.CLIENT
+        )
+        for field, value in attributes.model_dump(by_alias=True).items():
+            if value is not None:
+                span.set_attribute(field, value)
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+            span.set_status(StatusCode.OK)
+            span.end()
+            return result
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+            span.end()
+            raise
+    return traced_method
+
+
+def chat_create(original_method, version, tracer):
+    """Wrap the `chat_create` method."""
+
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["COHERE"]
+
+        message = kwargs.get("message", "")
+        prompts = json.dumps([
+            {
+                "role": "USER",
+                "content": message
+            }
+        ])
+        preamble = kwargs.get("preamble")
+        if preamble:
+            prompts = json.dumps(
+                [{"role": "system", "content": preamble}] + [{"role": "USER", "content": message}]
+            )
+
+        chat_history = kwargs.get("chat_history")
+        if chat_history:
+            history = [
+                {
+                    "message": {
+                        "role": (
+                            item.get("role") if item.get("role") is not None else "USER"
+                        ),
+                        "content": (
+                            item.get("message") if item.get("message") is not None else ""
+                        )
+                    }
+                }
+                for item in chat_history
+            ]
+            prompts = prompts + json.dumps(history)
+
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": APIS["CHAT_CREATE"]["URL"],
+            "llm.api": APIS["CHAT_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get("model") if kwargs.get("model") is not None else "command-r",
+            "llm.stream": False,
+            "llm.prompts": prompts,
+            **(extra_attributes if extra_attributes is not None else {})
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        if kwargs.get("temperature") is not None:
+            attributes.llm_temperature = kwargs.get("temperature")
+        if kwargs.get("max_tokens") is not None:
+            attributes.max_tokens = kwargs.get("max_tokens")
+        if kwargs.get("max_input_tokens") is not None:
+            attributes.max_input_tokens = kwargs.get("max_input_tokens")
+        if kwargs.get("p") is not None:
+            attributes.llm_top_p = kwargs.get("p")
+        if kwargs.get("k") is not None:
+            attributes.llm_top_p = kwargs.get("k")
+        if kwargs.get("user") is not None:
+            attributes.llm_user = kwargs.get("user")
+        if kwargs.get("conversation_id") is not None:
+            attributes.conversation_id = kwargs.get("conversation_id")
+        if kwargs.get("seed") is not None:
+            attributes.seed = kwargs.get("seed")
+        if kwargs.get("frequency_penalty") is not None:
+            attributes.frequency_penalty = kwargs.get("frequency_penalty")
+        if kwargs.get("presence_penalty") is not None:
+            attributes.presence_penalty = kwargs.get("presence_penalty")
+        if kwargs.get("connectors") is not None:
+            # stringify the list of objects
+            attributes.llm_connectors = json.dumps(kwargs.get("connectors"))
+        if kwargs.get("tools") is not None:
+            # stringify the list of objects
+            attributes.llm_tools = json.dumps(kwargs.get("tools"))
+        if kwargs.get("tool_results") is not None:
+            # stringify the list of objects
+            attributes.llm_tool_results = json.dumps(kwargs.get("tool_results"))
+
+        span = tracer.start_span(
+            APIS["CHAT_CREATE"]["METHOD"], kind=SpanKind.CLIENT
+        )
+
+        # Set the attributes on the span
+        for field, value in attributes.model_dump(by_alias=True).items():
+            if value is not None:
+                span.set_attribute(field, value)
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+
+            # Set the response attributes
+            if (hasattr(result, "generation_id")) and (result.generation_id is not None):
+                span.set_attribute("llm.generation_id", result.generation_id)
+            if (hasattr(result, "response_id")) and (result.response_id is not None):
+                span.set_attribute("llm.response_id", result.response_id)
+            if (hasattr(result, "is_search_required")) and (result.is_search_required is not None):
+                span.set_attribute("llm.is_search_required", result.is_search_required)
+
+            if kwargs.get("stream") is False or kwargs.get("stream") is None:
+                if hasattr(result, "text") and result.text is not None:
+                    if hasattr(result, "chat_history") and result.chat_history is not None:
+                        responses = [
+                            {
+                                "message": {
+                                    "role": (
+                                        item.role if hasattr(item, "role") and item.role is not None else "USER"
+                                    ),
+                                    "content": (
+                                        item.message if hasattr(item, "message") and item.message is not None else ""
+                                    )
+                                }
+                            }
+                            for item in result.chat_history
+                        ]
+                        span.set_attribute("llm.responses", json.dumps(responses))
+                    else:
+                        responses = [{
+                            "message": {
+                                "role": "CHATBOT",
+                                "content": result.text
+                            }
+                        }]
+                        span.set_attribute("llm.responses", json.dumps(responses))
+                else:
+                    responses = []
+                    span.set_attribute("llm.responses", json.dumps(responses))
+
+                # Get the usage
+                if hasattr(result, "meta") and result.meta is not None:
+                    if hasattr(result.meta, "billed_units") and result.meta.billed_units is not None:
+                        usage = result.meta.billed_units
+                        if usage is not None:
+                            usage_dict = {
+                                "input_tokens": usage.input_tokens if usage.input_tokens is not None else 0,
+                                "output_tokens": usage.output_tokens if usage.output_tokens is not None else 0,
+                                "total_tokens": usage.input_tokens + usage.output_tokens if usage.input_tokens is not None and usage.output_tokens is not None else 0,
+                            }
+                            span.set_attribute("llm.token.counts", json.dumps(usage_dict))
+                span.set_status(StatusCode.OK)
+                span.end()
+                return result
+            else:
+                # For older version, stream was passed as a parameter
+                return result
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+            span.end()
+            raise
+    return traced_method
+
+
+def chat_stream(original_method, version, tracer):
+    """Wrap the `messages_stream` method."""
+
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["COHERE"]
+
+        message = kwargs.get("message", "")
+        prompt_tokens = estimate_tokens(message)
+        prompts = json.dumps([
+            {
+                "role": "USER",
+                "content": message
+            }
+        ])
+        preamble = kwargs.get("preamble")
+        if preamble:
+            prompts = json.dumps(
+                [{"role": "system", "content": preamble}] + [{"role": "USER", "content": message}]
+            )
+
+        chat_history = kwargs.get("chat_history")
+        if chat_history:
+            history = [
+                {
+                    "message": {
+                        "role": (
+                            item.get("role") if item.get("role") is not None else "USER"
+                        ),
+                        "content": (
+                            item.get("message") if item.get("message") is not None else ""
+                        )
+                    }
+                }
+                for item in chat_history
+            ]
+            prompts = prompts + json.dumps(history)
+
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": APIS["CHAT_STREAM"]["URL"],
+            "llm.api": APIS["CHAT_STREAM"]["ENDPOINT"],
+            "llm.model": kwargs.get("model") if kwargs.get("model") is not None else "command-r",
+            "llm.stream": False,
+            "llm.prompts": prompts,
+            **(extra_attributes if extra_attributes is not None else {})
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        if kwargs.get("temperature") is not None:
+            attributes.llm_temperature = kwargs.get("temperature")
+        if kwargs.get("max_tokens") is not None:
+            attributes.max_tokens = kwargs.get("max_tokens")
+        if kwargs.get("max_input_tokens") is not None:
+            attributes.max_input_tokens = kwargs.get("max_input_tokens")
+        if kwargs.get("p") is not None:
+            attributes.llm_top_p = kwargs.get("p")
+        if kwargs.get("k") is not None:
+            attributes.llm_top_p = kwargs.get("k")
+        if kwargs.get("user") is not None:
+            attributes.llm_user = kwargs.get("user")
+        if kwargs.get("conversation_id") is not None:
+            attributes.conversation_id = kwargs.get("conversation_id")
+        if kwargs.get("seed") is not None:
+            attributes.seed = kwargs.get("seed")
+        if kwargs.get("frequency_penalty") is not None:
+            attributes.frequency_penalty = kwargs.get("frequency_penalty")
+        if kwargs.get("presence_penalty") is not None:
+            attributes.presence_penalty = kwargs.get("presence_penalty")
+        if kwargs.get("connectors") is not None:
+            # stringify the list of objects
+            attributes.llm_connectors = json.dumps(kwargs.get("connectors"))
+        if kwargs.get("tools") is not None:
+            # stringify the list of objects
+            attributes.llm_tools = json.dumps(kwargs.get("tools"))
+        if kwargs.get("tool_results") is not None:
+            # stringify the list of objects
+            attributes.llm_tool_results = json.dumps(kwargs.get("tool_results"))
+
+        span = tracer.start_span(
+            APIS["CHAT_CREATE"]["METHOD"], kind=SpanKind.CLIENT
+        )
+        for field, value in attributes.model_dump(by_alias=True).items():
+            if value is not None:
+                span.set_attribute(field, value)
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+
+            result_content = []
+            span.add_event(Event.STREAM_START.value)
+            completion_tokens = 0
+            try:
+                for event in result:
+                    if hasattr(event, "text") and event.text is not None:
+                        completion_tokens += estimate_tokens(event.text)
+                        content = event.text
+                    else:
+                        content = ""
+                    span.add_event(
+                        Event.STREAM_OUTPUT.value, {"response": "".join(content)}
+                    )
+                    result_content.append(content)
+                    yield event
+            finally:
+
+                # Finalize span after processing all chunks
+                span.add_event(Event.STREAM_END.value)
+                span.set_attribute(
+                    "llm.token.counts",
+                    json.dumps(
+                        {
+                            "input_tokens": prompt_tokens,
+                            "output_tokens": completion_tokens,
+                            "total_tokens": prompt_tokens + completion_tokens,
+                        }
+                    ),
+                )
+                span.set_attribute(
+                    "llm.responses",
+                    json.dumps(
+                        [
+                            {
+                                "message": {
+                                    "role": "CHATBOT",
+                                    "content": "".join(result_content),
+                                }
+                            }
+                        ]
+                    ),
+                )
+                span.set_status(StatusCode.OK)
+                span.end()
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+            span.end()
+            raise
+
+    return traced_method

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/src/langtrace_python_sdk/instrumentation/openai/patch.py

@@ -97,6 +97,12 @@ def chat_completions_create(original_method, version, tracer):
             else ""
         )
         service_provider = SERVICE_PROVIDERS["OPENAI"]
+        # If base url contains perplexity or azure, set the service provider accordingly
+        if "perplexity" in base_url:
+            service_provider = SERVICE_PROVIDERS["PPLX"]
+        elif "azure" in base_url:
+            service_provider = SERVICE_PROVIDERS["AZURE"]
+
         extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
 
         span_attributes = {
@@ -214,12 +220,10 @@ def chat_completions_create(original_method, version, tracer):
                     prompt_tokens,
                     function_call=kwargs.get("functions") is not None,
                 )
-        except Exception as e:
-            # Record the exception in the span
-            span.record_exception(e)
-            # Set the span status to indicate an error
-            span.set_status(Status(StatusCode.ERROR, str(e)))
-            # Reraise the exception to ensure it's not swallowed
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
             span.end()
             raise
 

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/src/langtrace_python_sdk/langtrace.py

@@ -32,6 +32,9 @@ from langtrace_python_sdk.instrumentation.openai.instrumentation import (
 from langtrace_python_sdk.instrumentation.pinecone.instrumentation import (
     PineconeInstrumentation,
 )
+from langtrace_python_sdk.instrumentation.cohere.instrumentation import (
+    CohereInstrumentation,
+)
 
 
 def init(
@@ -77,6 +80,7 @@ def init(
     langchain_core_instrumentation = LangchainCoreInstrumentation()
     langchain_community_instrumentation = LangchainCommunityInstrumentation()
     anthropic_instrumentation = AnthropicInstrumentation()
+    cohere_instrumentation = CohereInstrumentation()
 
     # Call the instrument method with some arguments
     openai_instrumentation.instrument()
@@ -87,3 +91,4 @@ def init(
     langchain_core_instrumentation.instrument()
     langchain_community_instrumentation.instrument()
     anthropic_instrumentation.instrument()
+    cohere_instrumentation.instrument()

langtrace_python_sdk-1.3.1/src/langtrace_python_sdk/version.py

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

{langtrace_python_sdk-1.2.23 → langtrace_python_sdk-1.3.1}/src/run_example.py

@@ -1,7 +1,7 @@
 # from examples.langchain_example.basic import basic, load_and_split, rag
 
 
-from examples.openai.chat_completion import chat_completion
+# from examples.openai.chat_completion import chat_completion
 
 # from examples.openai import images_generate
 # from examples.openai.function_calling import function_calling
@@ -11,12 +11,20 @@ from examples.openai.chat_completion import chat_completion
 # from examples.chroma_example.basic import basic
 # from examples.llamaindex_example.basic import basic
 # from examples.langchain_example.basic import basic
+# from examples.cohere_example.chat import chat_comp
+from examples.cohere_example.embed_create import embed_create
+# from examples.cohere_example.chat_stream import chat_stream
+
+# from examples.perplexity_example.basic import basic
 
 # load_and_split()
 # rag()
 # basic()
-chat_completion()
+# chat_completion()
 # function_calling()
 # images_generate()
 # embeddings_create()
 # messages_create()
+# chat_comp()
+embed_create()
+# chat_stream()

langtrace_python_sdk-1.2.23/src/langtrace_python_sdk/version.py

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