bump version

Author: karthikscale3

src/examples/cohere_example/rerank.py

@@ -1,5 +1,6 @@
 import cohere
 from dotenv import find_dotenv, load_dotenv
+from datetime import datetime
 
 from langtrace_python_sdk import langtrace
 
@@ -16,10 +17,22 @@
 # @with_langtrace_root_span("embed_create")
 def rerank():
     docs = [
-        "Carson City is the capital city of the American state of Nevada.",
-        "The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean. Its capital is Saipan.",
-        "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district.",
-        "Capital punishment (the death penalty) has existed in the United States since beforethe United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states.",
+        {
+            "text": "Carson City is the capital city of the American state of Nevada.",
+            "date": datetime.now(),
+        },
+        {
+            "text": "The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean. Its capital is Saipan.",
+            "date": datetime(2020, 5, 17),
+        },
+        {
+            "text": "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district.",
+            "date": datetime(1776, 7, 4),
+        },
+        {
+            "text": "Capital punishment (the death penalty) has existed in the United States since before the United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states.",
+            "date": datetime(2023, 9, 14),
+        },
     ]
 
     response = co.rerank(

src/examples/dspy_example/QA_basic.py

@@ -0,0 +1,20 @@
+import dspy
+from langtrace_python_sdk import langtrace
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
+
+# configure the language model to be used by dspy
+
+llm = dspy.Claude()
+dspy.settings.configure(lm=llm)
+
+# create a prompt format that says that the llm will take a question and give back an answer
+predict = dspy.Predict("question -> answer")
+prediction = predict(
+    question="who scored the final goal in football world cup finals in 2014?"
+)
+
+print(prediction.answer)

src/examples/dspy_example/QA_basic_with_chain_of_thought.py

@@ -0,0 +1,28 @@
+import dspy
+from langtrace_python_sdk import langtrace
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
+
+# configure the language model to be used by dspy
+llm = dspy.Claude()
+dspy.settings.configure(lm=llm)
+
+
+# create a signature for basic question answering
+class BasicQA(dspy.Signature):
+    """Given a question, generate the answer."""
+
+    question = dspy.InputField(desc="User's question")
+    answer = dspy.OutputField(desc="often between 1 and 5 words")
+
+
+# create a prompt format that says that the llm will take a question and give back an answer
+predict = dspy.ChainOfThought(BasicQA)
+prediction = predict(
+    question="Who provided the assist for the final goal in the 2014 FIFA World Cup final?"
+)
+
+print(prediction.answer)

src/examples/dspy_example/QA_basic_with_signature.py

@@ -0,0 +1,30 @@
+import dspy
+from langtrace_python_sdk import langtrace
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
+
+# configure the language model to be used by dspy
+llm = dspy.Claude()
+dspy.settings.configure(lm=llm)
+
+
+# create a signature for basic question answering
+class BasicQA(dspy.Signature):
+    """Answer questions with short factoid answers."""
+
+    question = dspy.InputField(
+        desc="A question that can be answered with a short factoid answer"
+    )
+    answer = dspy.OutputField(desc="often between 1 and 5 words")
+
+
+# create a prompt format that says that the llm will take a question and give back an answer
+predict = dspy.Predict(BasicQA)
+prediction = predict(
+    question="Sarah has 5 apples. She buys 7 more apples from the store. How many apples does Sarah have now?"
+)
+
+print(prediction.answer)

src/examples/dspy_example/QA_multi_step_with_chain_of_thought.py

@@ -0,0 +1,41 @@
+import dspy
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
+
+# configure the language model to be used by dspy
+llm = dspy.Claude()
+dspy.settings.configure(lm=llm)
+
+
+# create a signature for basic question answering
+class BasicQA(dspy.Signature):
+    """Given a question, generate the answer."""
+
+    question = dspy.InputField(desc="User's question")
+    answer = dspy.OutputField(desc="often between 1 and 5 words")
+
+
+class DoubleChainOfThought(dspy.Module):
+    def __init__(self):
+        self.cot1 = dspy.ChainOfThought("question -> step_by_step_thought")
+        self.cot2 = dspy.ChainOfThought("question, thought -> one_word_answer")
+
+    def forward(self, question):
+        thought = self.cot1(question=question).step_by_step_thought
+        answer = self.cot2(question=question, thought=thought).one_word_answer
+        return dspy.Prediction(thought=thought, answer=answer)
+
+
+@with_langtrace_root_span(name="Double Chain Of thought")
+def main():
+    multi_step_question = "what is the capital of the birth state of the person who provided the assist for the Mario Gotze's in football world cup in 2014?"
+    double_cot = DoubleChainOfThought()
+    result = double_cot(question=multi_step_question)
+    print(result)
+
+
+main()

src/examples/langchain_example/__init__.py

@@ -2,7 +2,7 @@
 from .basic import basic_app, rag, load_and_split
 from langtrace_python_sdk import with_langtrace_root_span
 
-from .groq_example import groq_basic, groq_streaming
+from .groq_example import groq_basic, groq_tool_choice, groq_streaming
 from .langgraph_example_tools import basic_graph_tools
 
 
@@ -20,3 +20,5 @@ class GroqRunner:
     @with_langtrace_root_span("Groq")
     def run(self):
         groq_streaming()
+        groq_basic()
+        groq_tool_choice()

src/examples/langchain_example/groq_example.py

@@ -1,6 +1,6 @@
+import json
+
 from dotenv import find_dotenv, load_dotenv
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_groq import ChatGroq
 from groq import Groq
 
 _ = load_dotenv(find_dotenv())
@@ -30,6 +30,82 @@ def groq_basic():
     return chat_completion
 
 
+def groq_tool_choice():
+
+    user_prompt = "What is 25 * 4 + 10?"
+    MODEL = "llama3-groq-70b-8192-tool-use-preview"
+
+    def calculate(expression):
+        """Evaluate a mathematical expression"""
+        try:
+            result = eval(expression)
+            return json.dumps({"result": result})
+        except:
+            return json.dumps({"error": "Invalid expression"})
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a calculator assistant. Use the calculate function to perform mathematical operations and provide the results.",
+        },
+        {
+            "role": "user",
+            "content": user_prompt,
+        },
+    ]
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "calculate",
+                "description": "Evaluate a mathematical expression",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "expression": {
+                            "type": "string",
+                            "description": "The mathematical expression to evaluate",
+                        }
+                    },
+                    "required": ["expression"],
+                },
+            },
+        }
+    ]
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        tools=tools,
+        tool_choice={"type": "function", "function": {"name": "calculate"}},
+        max_tokens=4096,
+    )
+
+    response_message = response.choices[0].message
+    tool_calls = response_message.tool_calls
+    if tool_calls:
+        available_functions = {
+            "calculate": calculate,
+        }
+        messages.append(response_message)
+        for tool_call in tool_calls:
+            function_name = tool_call.function.name
+            function_to_call = available_functions[function_name]
+            function_args = json.loads(tool_call.function.arguments)
+            function_response = function_to_call(
+                expression=function_args.get("expression")
+            )
+            messages.append(
+                {
+                    "tool_call_id": tool_call.id,
+                    "role": "tool",
+                    "name": function_name,
+                    "content": function_response,
+                }
+            )
+        second_response = client.chat.completions.create(model=MODEL, messages=messages)
+        return second_response.choices[0].message.content
+
+
 def groq_streaming():
     chat_completion = client.chat.completions.create(
         messages=[

src/langtrace_python_sdk/extensions/langtrace_exporter.py

@@ -124,7 +124,7 @@ def export(self, spans: typing.Sequence[ReadableSpan]) -> SpanExportResult:
                 url=f"{self.api_host}",
                 data=json.dumps(data),
                 headers=headers,
-                timeout=20,
+                timeout=40,
             )
 
             if not response.ok:

src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -14,10 +14,8 @@
 limitations under the License.
 """
 
-from typing import Any, Callable, Dict, List, Optional, Iterator, TypedDict, Union
-from langtrace.trace_attributes import Event, SpanAttributes, LLMSpanAttributes
-from langtrace_python_sdk.utils import set_span_attribute
-from langtrace_python_sdk.utils.silently_fail import silently_fail
+from typing import Any, Callable, List, Iterator, Union
+from langtrace.trace_attributes import SpanAttributes, LLMSpanAttributes
 import json
 
 from langtrace_python_sdk.utils.llm import (
@@ -28,6 +26,7 @@
     get_llm_url,
     get_span_name,
     set_event_completion,
+    set_span_attributes,
     set_usage_attributes,
     set_span_attribute,
 )
@@ -39,8 +38,6 @@
     StreamingResult,
     ResultType,
     MessagesCreateKwargs,
-    ContentItem,
-    Usage,
 )
 
 
@@ -62,22 +59,20 @@ def traced_method(
             prompts = [{"role": "system", "content": system}] + kwargs.get(
                 "messages", []
             )
-        extraAttributes = get_extra_attributes()
         span_attributes = {
             **get_langtrace_attributes(version, service_provider),
             **get_llm_request_attributes(kwargs, prompts=prompts),
             **get_llm_url(instance),
             SpanAttributes.LLM_PATH: APIS["MESSAGES_CREATE"]["ENDPOINT"],
-            **extraAttributes,  # type: ignore
+            **get_extra_attributes(),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
 
         span = tracer.start_span(
             name=get_span_name(APIS["MESSAGES_CREATE"]["METHOD"]), kind=SpanKind.CLIENT
         )
-        for field, value in attributes.model_dump(by_alias=True).items():
-            set_span_attribute(span, field, value)
+        set_span_attributes(span, attributes)
         try:
             # Attempt to call the original method
             result = wrapped(*args, **kwargs)
@@ -112,7 +107,7 @@ def set_response_attributes(
                     if typ == "text":
                         content = result.content[0].text
                         set_event_completion(
-                            span, [{"type": typ, role: role, content: content}]
+                            span, [{"type": typ, "role": role, "content": content}]
                         )
 
             if (

src/langtrace_python_sdk/instrumentation/autogen/instrumentation.py

@@ -10,15 +10,9 @@ def instrumentation_dependencies(self):
         return ["autogen >= 0.1.0"]
 
     def _instrument(self, **kwargs):
-        print("Instrumneting autogen")
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, "", tracer_provider)
         version = v("autogen")
-        # conversable_agent.intiate_chat
-        # conversable_agent.register_function
-        # agent.Agent
-        # AgentCreation
-        # Tools --> Register_for_llm, register_for_execution, register_for_function
         try:
             _W(
                 module="autogen.agentchat.conversable_agent",