Merge branch 'development' of github.com:Scale3-Labs/langtrace-python-sdk into obinna/S3EN-2344-instrument-mistral

Author: alizenhom

src/examples/crewai_example/trip_planner/agents.py

@@ -12,9 +12,9 @@ class TravelAgents:
     def __init__(self):
         self.OpenAIGPT35 = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.7)
         self.OpenAIGPT4 = ChatOpenAI(model_name="gpt-4", temperature=0.7)
-        self.Ollama = ChatOllama(model="openhermes")
+        self.Ollama = ChatOllama(model="llama3")
         self.Cohere = ChatCohere(model="command-r")
-        self.Anthropic = ChatAnthropic(model="claude-3-5-sonnet")
+        self.Anthropic = ChatAnthropic(model="claude-3-5-sonnet-20240620")
 
     def expert_travel_agent(self):
         return Agent(
@@ -28,7 +28,7 @@ def expert_travel_agent(self):
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )
 
     def city_selection_expert(self):
@@ -39,7 +39,7 @@ def city_selection_expert(self):
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )
 
     def local_tour_guide(self):
@@ -50,5 +50,5 @@ def local_tour_guide(self):
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )

src/examples/litellm_example/basic.py

@@ -0,0 +1,98 @@
+from langtrace_python_sdk import with_langtrace_root_span, langtrace
+from dotenv import load_dotenv
+from litellm import completion, acompletion
+import litellm
+import asyncio
+
+load_dotenv()
+
+
+litellm.success_callback = ["langtrace"]
+langtrace.init()
+litellm.set_verbose = False
+
+
+@with_langtrace_root_span("Litellm Example OpenAI")
+def openAI(streaming=False):
+    response = completion(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"content": "respond only in Yoda speak.", "role": "system"},
+            {"content": "Hello, how are you?", "role": "user"},
+        ],
+        stream=streaming,
+        stream_options={"include_usage": True},
+    )
+    if streaming:
+        for _ in response:
+            pass
+    else:
+        return response
+
+
+# @with_langtrace_root_span("Litellm Example Anthropic Completion")
+def anthropic(streaming=False):
+    try:
+
+        response = completion(
+            model="claude-2.1",
+            messages=[
+                {"content": "respond only in Yoda speak.", "role": "system"},
+                {"content": "what is 2 + 2?", "role": "user"},
+            ],
+            temperature=0.5,
+            top_p=0.5,
+            n=1,
+            stream=streaming,
+            stream_options={"include_usage": True},
+        )
+        # print(response)
+        if streaming:
+            for _ in response:
+                pass
+        else:
+            return response
+    except Exception as e:
+        print("ERORRRR", e)
+
+
+# @with_langtrace_root_span("Litellm Example OpenAI Async Streaming")
+async def async_anthropic(streaming=False):
+    response = await acompletion(
+        model="claude-2.1",
+        messages=[{"content": "Hello, how are you?", "role": "user"}],
+        stream=streaming,
+        stream_options={"include_usage": True},
+        temperature=0.5,
+        top_p=0.5,
+        n=1,
+    )
+    if streaming:
+        async for _ in response:
+            pass
+    else:
+        return response
+
+
+def cohere(streaming=False):
+    response = completion(
+        model="command-r",
+        messages=[
+            {"content": "respond only in Yoda speak.", "role": "system"},
+            {"content": "Hello, how are you?", "role": "user"},
+        ],
+        stream=streaming,
+        stream_options={"include_usage": True},
+    )
+    if streaming:
+        for _ in response:
+            pass
+    else:
+        return response
+
+
+if __name__ == "__main__":
+    # openAI()
+    anthropic(streaming=False)
+    cohere(streaming=True)
+    # asyncio.run(async_anthropic(streaming=True))

src/examples/weaviate_example/query_text.py

@@ -15,13 +15,14 @@
 import requests
 import weaviate
 import weaviate.classes as wvc
+import weaviate.classes.config as wc
+from dotenv import load_dotenv
 from weaviate.classes.aggregate import GroupByAggregate
 from weaviate.classes.query import Filter, HybridFusion, MetadataQuery
 from weaviate.collections.classes.grpc import Move
 
 import langtrace_python_sdk.langtrace as langtrace
 from langtrace_python_sdk import with_langtrace_root_span
-from dotenv import load_dotenv
 
 load_dotenv()
 # Set these environment variables
@@ -44,11 +45,16 @@ def create():
     if not client.collections.get("Question"):
         questions = client.collections.create(
             name="Question",
-            # Set the vectorizer to "text2vec-openai" to use the OpenAI API for vector-related operations
-            vectorizer_config=wvc.config.Configure.Vectorizer.text2vec_openai(),
-            # Ensure the `generative-openai` module is used for generative queries
-            generative_config=wvc.config.Configure.Generative.openai(),
-        )
+        properties=[
+            wc.Property(name="answer", data_type=wc.DataType.TEXT),
+            wc.Property(name="question", data_type=wc.DataType.TEXT),
+            wc.Property(name="category", data_type=wc.DataType.TEXT),
+        ],
+        # Define the vectorizer module
+        vectorizer_config=wc.Configure.Vectorizer.text2vec_openai(),
+        # Define the generative module
+        generative_config=wc.Configure.Generative.openai(),
+    )
 
 
 @with_langtrace_root_span("insert")

src/langtrace_python_sdk/instrumentation/weaviate/instrumentation.py

@@ -37,7 +37,7 @@ class WeaviateInstrumentation(BaseInstrumentor):
     """
 
     def instrumentation_dependencies(self) -> Collection[str]:
-        return ["weaviate-client >= 4.6.1", "trace-attributes >= 4.0.2"]
+        return ["weaviate-client >= 4.6.1", "trace-attributes >= 7.0.3"]
 
     def _instrument(self, **kwargs):
         tracer_provider = kwargs.get("tracer_provider")

src/langtrace_python_sdk/instrumentation/weaviate/patch.py

@@ -16,21 +16,21 @@
 
 import json
 
+from importlib_metadata import version as v
 from langtrace.trace_attributes import DatabaseSpanAttributes
-from langtrace_python_sdk.utils.llm import get_span_name
 from opentelemetry import baggage, trace
 from opentelemetry.trace import SpanKind
-from opentelemetry.trace.status import Status, StatusCode
 from opentelemetry.trace.propagation import set_span_in_context
+from opentelemetry.trace.status import Status, StatusCode
+
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
 from langtrace_python_sdk.constants.instrumentation.common import (
     LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
     SERVICE_PROVIDERS,
 )
 from langtrace_python_sdk.constants.instrumentation.weaviate import APIS
+from langtrace_python_sdk.utils.llm import get_span_name
 from langtrace_python_sdk.utils.misc import extract_input_params, to_iso_format
-from importlib_metadata import version as v
-
-from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
 
 # Predefined metadata response attributes
 METADATA_ATTRIBUTES = [
@@ -45,6 +45,22 @@
 ]
 
 
+def extract_inputs(args, kwargs):
+    extracted_params = {}
+    kwargs_without_properties = {k: v for k, v in kwargs.items() if k != "properties"}
+    extracted_params.update(extract_input_params(args, kwargs_without_properties))
+
+    if kwargs.get("properties", None):
+        extracted_params["properties"] = []
+        for each_prop in kwargs.get("properties"):
+            if hasattr(each_prop, "_to_dict"):
+                # append properties to extracted_params
+                extracted_params["properties"].append(each_prop._to_dict())
+
+        extracted_params["properties"] = json.dumps(extracted_params["properties"])
+    return extracted_params
+
+
 def extract_metadata(metadata):
     # Extraction response Query metadata
     extracted_metadata = {
@@ -126,7 +142,7 @@ def traced_method(wrapped, instance, args, kwargs):
             "db.system": "weaviate",
             "db.operation": api["OPERATION"],
             "db.collection.name": collection_name,
-            "db.query": json.dumps(extract_input_params(args, kwargs)),
+            "db.query": json.dumps(extract_inputs(args, kwargs)),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
@@ -143,7 +159,6 @@ def traced_method(wrapped, instance, args, kwargs):
             try:
                 # Attempt to call the original method
                 result = wrapped(*args, **kwargs)
-                print(result)
                 if api["OPERATION"] in ["query", "generate"]:
                     span.add_event(
                         name="db.response",

src/langtrace_python_sdk/langtrace.py

@@ -73,7 +73,7 @@ def init(
     disable_instrumentations: Optional[DisableInstrumentations] = None,
     disable_tracing_for_functions: Optional[InstrumentationMethods] = None,
     service_name: Optional[str] = None,
-    disable_logging = False
+    disable_logging=False,
 ):
     if disable_logging:
         sys.stdout = open(os.devnull, "w")
@@ -94,7 +94,9 @@ def init(
     provider = TracerProvider(resource=resource, sampler=sampler)
 
     remote_write_exporter = (
-        LangTraceExporter(api_key=api_key, api_host=host, disable_logging=disable_logging)
+        LangTraceExporter(
+            api_key=api_key, api_host=host, disable_logging=disable_logging
+        )
         if custom_remote_exporter is None
         else custom_remote_exporter
     )