langtrace-python-sdk 1.2.23__py3-none-any.whl → 1.3.1__py3-none-any.whl

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)

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

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)

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}

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/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/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/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/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/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/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/version.py

@@ -1 +1 @@
-__version__ = "1.2.23"
+__version__ = "1.3.1"

{langtrace_python_sdk-1.2.23.dist-info → langtrace_python_sdk-1.3.1.dist-info}/METADATA

@@ -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.dist-info → langtrace_python_sdk-1.3.1.dist-info}/RECORD

@@ -3,6 +3,11 @@ examples/anthropic_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 examples/anthropic_example/completion.py,sha256=97CA6u7iLdTj6qQ5XA7nB0bcNMxUwXJKpNYSCW-BM6Q,791
 examples/chroma_example/__init__.py,sha256=Tq6pae7fHA7dwuDslabB5MTNedL21gu2RaZicpxSyLU,25
 examples/chroma_example/basic.py,sha256=VE-I7Db58Dyb0G6WgX9FeloHLGuRRvfB4aNvSIVL4Uk,910
+examples/cohere_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/cohere_example/chat.py,sha256=MpTyvXPNTMcjKzQUsF4xepwTxBNcDbUYmjawzjZIIo4,889
+examples/cohere_example/chat_stream.py,sha256=t9XmyC_sT3ZdDQKzECPcX-8hpyYzrL6OXihsAKmPxTA,680
+examples/cohere_example/embed_create.py,sha256=JYLCfnES4TX-RbU6n3wIlLEfr5pfCwOwdRopjvxytew,552
+examples/fastapi_example/basic_route.py,sha256=3wu1cogsR9eeuwid9kRBepVxMUZ0np-T5qkmsvQh0Lw,1145
 examples/langchain_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/langchain_example/basic.py,sha256=mSVcE-Kx7jNS4U_zrm5WZI98xyw6WTrhd2GMVGgn9Cg,2653
 examples/langchain_example/tool.py,sha256=8T8_IDbgA58XbsfyH5_xhA8ZKQfyfyFxF8wor-PsRjA,2556
@@ -14,17 +19,19 @@ examples/openai/chat_completion.py,sha256=ynVWdvEwDxNPpkWu9fv4al7_1mm3rFilFvqkrc
 examples/openai/embeddings_create.py,sha256=AhDNAqg-WzRYLJAE_b2RKGjuVCh4aZSU7MxcZv2kCHQ,518
 examples/openai/function_calling.py,sha256=Zd1gkl1TU-g_cxXox3_8vmFRZVyZSyyLaboEJLc6N2A,2375
 examples/openai/images_generate.py,sha256=ZioxTuHKE_yYlhpESqXKVzdkiwdegkmLVB7N8T2LU00,506
+examples/perplexity_example/basic.py,sha256=jEqZnY9cmDezMAwMvKaZeRk7vW1H68Zc2de3gDnb6hg,704
 examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/pinecone_example/basic.py,sha256=hdV6-5Fmol9zeyFzDtdabD62vkqUJ4lCHG2YcVNpIpI,933
 langtrace_python_sdk/__init__.py,sha256=SlHg447-nQBbw8exRNJP_OyHUZ39Sldb7aaQ35hIRm8,262
-langtrace_python_sdk/langtrace.py,sha256=0gT4eCn8-hSSfI-B5zxUmd7weHvuCsnS4B7N4EmFzHs,3251
-langtrace_python_sdk/version.py,sha256=y_Ev8AcJxzZe4ZJWlW3Wsver97OJUqU1nFSDqHzKBDw,23
+langtrace_python_sdk/langtrace.py,sha256=-9WC49AOmxmEWl_fUXkEAKgshg3pmI5J-_d_1hITjY8,3447
+langtrace_python_sdk/version.py,sha256=-ypEJktJToAL9by62JJKWEzDo_KPCQtmE5kwFgX24z4,22
 langtrace_python_sdk/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=5MNjnAOg-4am78J3gVMH6FSwq5N8TOj72ugkhsw4vi0,46
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/constants/instrumentation/anthropic.py,sha256=YX3llt3zwDY6XrYk3CB8WEVqgrzRXEw_ffyk56JoF3k,126
 langtrace_python_sdk/constants/instrumentation/chroma.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
-langtrace_python_sdk/constants/instrumentation/common.py,sha256=KzNCWEl_44pkZ5DcBBLAInh-QNgSMPSBkbhIcC8rH0A,602
+langtrace_python_sdk/constants/instrumentation/cohere.py,sha256=jB6PsLmvoRAIjpbuv9j-59_VRL0OW3w5BiB54a72jBc,445
+langtrace_python_sdk/constants/instrumentation/common.py,sha256=iqoWV1laoFxzqqwzNmkCrbyVo64n3nrwSoY_r57Sx3g,652
 langtrace_python_sdk/constants/instrumentation/openai.py,sha256=9VF6ic9Ed3bpSvdp6iNmrpx2Ppo6DPav3hoUcqSQSv0,1048
 langtrace_python_sdk/constants/instrumentation/pinecone.py,sha256=Xaqqw-xBO0JJLGk75hiCUQGztNm0HiVaLQvjtYK7VJM,472
 langtrace_python_sdk/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,6 +43,9 @@ langtrace_python_sdk/instrumentation/anthropic/patch.py,sha256=BovObJMmux-VbumON
 langtrace_python_sdk/instrumentation/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/chroma/instrumentation.py,sha256=9k8KueizRJuicJnuYmSvjLwdeCNszZ1KpwZPMsQ_7ig,1280
 langtrace_python_sdk/instrumentation/chroma/patch.py,sha256=fddeGMP8obll2Tra04S8C0jEiJ97v_y1WC1QdO4bO4A,2303
+langtrace_python_sdk/instrumentation/cohere/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langtrace_python_sdk/instrumentation/cohere/instrumentation.py,sha256=-DWjAq4_H3Q8MCyH2qt3NiLndgrRy9BIUbrZZHsY0pY,1431
+langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=PpDEmWc3XFnrFOvyytluaJN25TQqE4ZOR0WZMYqzg2E,15727
 langtrace_python_sdk/instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/langchain/instrumentation.py,sha256=UBUx31IErih1zDGkwez5ZFT2qGvCHxhdGHvJsEyhvEo,2938
 langtrace_python_sdk/instrumentation/langchain/patch.py,sha256=ofageMjQZ_AGlnfknBI06dkaDsyNuqYRz-3EZhv9izY,3294
@@ -50,14 +60,14 @@ langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=wVSvxS
 langtrace_python_sdk/instrumentation/llamaindex/patch.py,sha256=NqBsPM4eE3yMu1aIev8p8yH5Thsv72JL68ABEZNe2ug,2043
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=stlFopPggB8mgnn4QdVh41rmA8mlzH5x-C00XHfApCE,1408
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=iP4RFL5ZHqu3BlNNq5DmmstLMaqaXmk4VKRbGXts1EI,15341
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=fTyZudq7hjk-BEZad4ayX6SaCCF0053_mSmeC43Lu-c,15463
 langtrace_python_sdk/instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/pinecone/instrumentation.py,sha256=o0EUd5jvHaDKOUTj4NjnL5UfDHDHxyXkWGlTW4oeRDk,1784
 langtrace_python_sdk/instrumentation/pinecone/patch.py,sha256=5lF7hQmg2-U2EWtOC0w8_peRaNMysBomb0fjiNoS6eQ,2200
 langtrace_python_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/utils/llm.py,sha256=4z2e-md_ELXCEuOIRVWracR6qH2pmsOxCqpkuF9_3Nw,1589
 langtrace_python_sdk/utils/with_root_span.py,sha256=N7ONrcF0myZbHBy5gpQffDbX-Kf63Crsz9szG0i3m08,1889
-langtrace_python_sdk-1.2.23.dist-info/METADATA,sha256=FrUpX6lKaLyKtHV7C-nIZWELcnozVZYvtyFh-Uh6jeQ,7695
-langtrace_python_sdk-1.2.23.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
-langtrace_python_sdk-1.2.23.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-1.2.23.dist-info/RECORD,,
+langtrace_python_sdk-1.3.1.dist-info/METADATA,sha256=eTyOCa7I4N386Gi0evo8yefecH0ntGFMK2nSzihOVfg,9061
+langtrace_python_sdk-1.3.1.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
+langtrace_python_sdk-1.3.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-1.3.1.dist-info/RECORD,,