langtrace-python-sdk 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

examples/langchain_example/groq_example.py

@@ -0,0 +1,30 @@
+from dotenv import find_dotenv, load_dotenv
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_groq import ChatGroq
+
+_ = load_dotenv(find_dotenv())
+
+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()
+
+
+def groq_example():
+
+    chat = ChatGroq(temperature=0, model_name="mixtral-8x7b-32768")
+
+    system = "You are a helpful assistant."
+    human = "{text}"
+    prompt = ChatPromptTemplate.from_messages([("system", system), ("human", human)])
+
+    chain = prompt | chat
+    result = chain.invoke({"text": "Explain the importance of low latency LLMs in 2 sentences or less."})
+    # print(result)
+    return result
+
+
+groq_example()

examples/langchain_example/langgraph_example.py

@@ -0,0 +1,85 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from langchain_core.messages import HumanMessage, ToolMessage
+from langchain_core.tools import tool
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, MessageGraph
+
+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()
+
+
+@tool
+def multiply(first_number: int, second_number: int):
+    """Multiplies two numbers together."""
+    return first_number * second_number
+
+
+model = ChatOpenAI(temperature=0)
+model_with_tools = model.bind(tools=[convert_to_openai_tool(multiply)])
+
+
+def invoke_model(state):
+    return model_with_tools.invoke(state)
+
+
+def router(state):
+    tool_calls = state[-1].additional_kwargs.get("tool_calls", [])
+    if len(tool_calls):
+        return "multiply"
+    else:
+        return "end"
+
+
+def invoke_tool(state):
+    tool_calls = state[-1].additional_kwargs.get("tool_calls", [])
+    multiply_call = None
+
+    for tool_call in tool_calls:
+        if tool_call.get("function").get("name") == "multiply":
+            multiply_call = tool_call
+
+    if multiply_call is None:
+        raise Exception("No adder input found.")
+
+    res = multiply.invoke(
+        json.loads(multiply_call.get("function").get("arguments"))
+    )
+
+    return ToolMessage(
+        tool_call_id=multiply_call.get("id"),
+        content=res
+    )
+
+
+@with_langtrace_root_span('langgraph_example')
+def basic():
+
+    graph = MessageGraph()
+
+    graph.add_node("oracle", invoke_model)
+
+    graph.add_node("multiply", invoke_tool)
+
+    graph.add_conditional_edges("oracle", router, {
+        "multiply": "multiply",
+        "end": END,
+    })
+
+    graph.add_edge("multiply", END)
+
+    graph.set_entry_point("oracle")
+
+    runnable = graph.compile()
+
+    answer = runnable.invoke(HumanMessage("What is 1 + 1?"))
+    print(answer)
+
+
+basic()

examples/qdrant_example/basic.py

@@ -0,0 +1,50 @@
+import cohere
+from dotenv import find_dotenv, load_dotenv
+from qdrant_client import QdrantClient
+from qdrant_client.models import Batch, Distance, VectorParams
+
+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(write_to_langtrace_cloud=False)
+
+
+@with_langtrace_root_span()
+def basic():
+    client = QdrantClient(":memory:")
+    cohere_client = cohere.Client()
+
+    client.create_collection(collection_name="MyCollection4", vectors_config=VectorParams(
+        size=1024,
+        distance=Distance.COSINE,
+    ))
+
+    client.upsert(
+        collection_name="MyCollection4",
+        points=Batch(
+            ids=[1],
+            vectors=cohere_client.embed(
+                model="embed-english-v3.0",  # New Embed v3 model
+                input_type="search_document",  # Input type for documents
+                texts=["Qdrant is the a vector database written in Rust"],
+            ).embeddings,
+        ),
+    )
+
+    answer = client.search(
+        collection_name="MyCollection4",
+        query_vector=cohere_client.embed(
+            model="embed-english-v3.0",  # New Embed v3 model
+            input_type="search_query",  # Input type for search queries
+            texts=["Which database is written in Rust?"],
+        ).embeddings[0],
+
+    )
+    print(answer[0])
+
+    return answer
+
+
+basic()

langtrace_python_sdk/constants/instrumentation/common.py

@@ -10,14 +10,17 @@ SERVICE_PROVIDERS = {
     "ANTHROPIC": "Anthropic",
     "AZURE": "Azure",
     "CHROMA": "Chroma",
+    "GROQ": "Groq",
     "LANGCHAIN": "Langchain",
     "LANGCHAIN_COMMUNITY": "Langchain Community",
     "LANGCHAIN_CORE": "Langchain Core",
+    "LANGGRAPH": "Langgraph",
     "LLAMAINDEX": "LlamaIndex",
     "OPENAI": "OpenAI",
     "PINECONE": "Pinecone",
     "COHERE": "Cohere",
     "PPLX": "Perplexity",
+    "QDRANT": "Qdrant",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk/constants/instrumentation/groq.py

@@ -0,0 +1,8 @@
+
+
+APIS = {
+    "CHAT_COMPLETION": {
+        "METHOD": "groq.chat.completions.create",
+        "ENDPOINT": "/chat/completions",
+    },
+}

langtrace_python_sdk/constants/instrumentation/qdrant.py

@@ -0,0 +1,72 @@
+from langtrace.trace_attributes import QdrantDBMethods
+
+APIS = {
+    "ADD": {
+        "METHOD": QdrantDBMethods.ADD.value,
+        "OPERATION": "add",
+    },
+    "GET_COLLECTION": {
+        "METHOD": QdrantDBMethods.GET_COLLECTION.value,
+        "OPERATION": "get_collection",
+    },
+    "GET_COLLECTIONS": {
+        "METHOD": QdrantDBMethods.GET_COLLECTIONS.value,
+        "OPERATION": "get_collections",
+    },
+    "QUERY": {
+        "METHOD": QdrantDBMethods.QUERY.value,
+        "OPERATION": "query",
+    },
+    "QUERY_BATCH": {
+        "METHOD": QdrantDBMethods.QUERY_BATCH.value,
+        "OPERATION": "query_batch",
+    },
+    "DELETE": {
+        "METHOD": QdrantDBMethods.DELETE.value,
+        "OPERATION": "delete",
+    },
+    "DISCOVER": {
+        "METHOD": QdrantDBMethods.DISCOVER.value,
+        "OPERATION": "discover",
+    },
+    "DISCOVER_BATCH": {
+        "METHOD": QdrantDBMethods.DISCOVER_BATCH.value,
+        "OPERATION": "discover_batch",
+    },
+    "RECOMMEND": {
+        "METHOD": QdrantDBMethods.RECOMMEND.value,
+        "OPERATION": "recommend",
+    },
+    "RECOMMEND_BATCH": {
+        "METHOD": QdrantDBMethods.RECOMMEND_BATCH.value,
+        "OPERATION": "recommend_batch",
+    },
+    "RETRIEVE": {
+        "METHOD": QdrantDBMethods.RETRIEVE.value,
+        "OPERATION": "retrieve",
+    },
+    "SEARCH": {
+        "METHOD": QdrantDBMethods.SEARCH.value,
+        "OPERATION": "search",
+    },
+    "SEARCH_BATCH": {
+        "METHOD": QdrantDBMethods.SEARCH_BATCH.value,
+        "OPERATION": "search_batch",
+    },
+    "UPSERT": {
+        "METHOD": QdrantDBMethods.UPSERT.value,
+        "OPERATION": "upsert",
+    },
+    "COUNT": {
+        "METHOD": QdrantDBMethods.COUNT.value,
+        "OPERATION": "count",
+    },
+    "UPDATE_COLLECTION": {
+        "METHOD": QdrantDBMethods.UPDATE_COLLECTION.value,
+        "OPERATION": "update_collection",
+    },
+    "UPDATE_VECTORS": {
+        "METHOD": QdrantDBMethods.UPDATE_VECTORS.value,
+        "OPERATION": "update_vectors",
+    },
+}

langtrace_python_sdk/instrumentation/groq/instrumentation.py

@@ -0,0 +1,56 @@
+"""
+Copyright (c) 2024 Scale3 Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import importlib.metadata
+import logging
+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.groq.patch import (
+    async_chat_completions_create, chat_completions_create)
+
+logging.basicConfig(level=logging.FATAL)
+
+
+class GroqInstrumentation(BaseInstrumentor):
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["groq >= 0.5.0"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("groq")
+
+        wrap_function_wrapper(
+            "groq.resources.chat.completions",
+            "Completions.create",
+            chat_completions_create("groq.chat.completions.create", version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "groq.resources.chat.completions",
+            "AsyncCompletions.create",
+            async_chat_completions_create(
+                "groq.chat.completions.create_stream", version, tracer
+            ),
+        )
+
+    def _uninstrument(self, **kwargs):
+        pass