langtrace-python-sdk 1.2.25__py3-none-any.whl → 1.3.2__py3-none-any.whl

examples/anthropic_example/completion.py

@@ -8,7 +8,7 @@ from langtrace_python_sdk import with_langtrace_root_span
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init(batch=False, debug_log_to_console=True, write_to_langtrace_cloud=False)
+langtrace.init(write_to_langtrace_cloud=False)
 
 @with_langtrace_root_span("messages_create")
 def messages_create():

examples/chroma_example/basic.py

@@ -7,7 +7,7 @@ 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)
+langtrace.init(write_to_langtrace_cloud=False)
 
 
 @with_langtrace_root_span()

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(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,24 @@
+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(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,22 @@
+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(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,40 @@
+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)
+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/hiveagent_example/basic.py

@@ -0,0 +1,23 @@
+from langtrace_python_sdk import langtrace
+from hive_agent import HiveAgent
+from dotenv import load_dotenv
+from openai import OpenAI
+
+load_dotenv()
+
+langtrace.init(
+    write_to_langtrace_cloud=False,
+    api_host="http://localhost:3000",
+)
+
+client = OpenAI()
+
+
+def basic():
+    my_agent = HiveAgent(
+        name="my_agent",
+        functions=[],
+        instruction="your instructions for this agent's goal",
+    )
+
+    my_agent.run_server()

examples/llamaindex_example/agent.py

@@ -0,0 +1,86 @@
+import json
+from typing import Sequence, List
+
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from llama_index.core.llms import ChatMessage
+from llama_index.core.tools import BaseTool, FunctionTool
+from openai.types.chat import ChatCompletionMessageToolCall
+from langtrace_python_sdk import langtrace
+
+import nest_asyncio
+
+nest_asyncio.apply()
+
+langtrace.init(write_to_langtrace_cloud=False)
+
+
+def multiply(a: int, b: int) -> int:
+    """Multiple two integers and returns the result integer"""
+    return a * b
+
+
+multiply_tool = FunctionTool.from_defaults(fn=multiply)
+
+
+def add(a: int, b: int) -> int:
+    """Add two integers and returns the result integer"""
+    return a + b
+
+
+add_tool = FunctionTool.from_defaults(fn=add)
+
+
+class YourOpenAIAgent:
+    def __init__(
+        self,
+        tools: Sequence[BaseTool] = [],
+        llm: OpenAI = OpenAI(temperature=0, model="gpt-3.5-turbo-0613"),
+        chat_history: List[ChatMessage] = [],
+    ) -> None:
+        self._llm = llm
+        self._tools = {tool.metadata.name: tool for tool in tools}
+        self._chat_history = chat_history
+
+    def reset(self) -> None:
+        self._chat_history = []
+
+    def chat(self, message: str) -> str:
+        chat_history = self._chat_history
+        chat_history.append(ChatMessage(role="user", content=message))
+        tools = [tool.metadata.to_openai_tool() for _, tool in self._tools.items()]
+
+        ai_message = self._llm.chat(chat_history, tools=tools).message
+        additional_kwargs = ai_message.additional_kwargs
+        chat_history.append(ai_message)
+
+        tool_calls = additional_kwargs.get("tool_calls", None)
+        # parallel function calling is now supported
+        if tool_calls is not None:
+            for tool_call in tool_calls:
+                function_message = self._call_function(tool_call)
+                chat_history.append(function_message)
+                ai_message = self._llm.chat(chat_history).message
+                chat_history.append(ai_message)
+
+        return ai_message.content
+
+    def _call_function(self, tool_call: ChatCompletionMessageToolCall) -> ChatMessage:
+        id_ = tool_call.id
+        function_call = tool_call.function
+        tool = self._tools[function_call.name]
+        output = tool(**json.loads(function_call.arguments))
+        return ChatMessage(
+            name=function_call.name,
+            content=str(output),
+            role="tool",
+            additional_kwargs={
+                "tool_call_id": id_,
+                "name": function_call.name,
+            },
+        )
+
+
+# agent = YourOpenAIAgent(tools=[multiply_tool, add_tool])
+llm = OpenAI(model="gpt-3.5-turbo-0613")
+agent = OpenAIAgent.from_tools([multiply_tool, add_tool], llm=llm, verbose=True)

examples/llamaindex_example/basic.py

@@ -7,7 +7,7 @@ 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)
+langtrace.init(write_to_langtrace_cloud=False)
 
 
 @with_langtrace_root_span()

examples/openai/chat_completion.py

@@ -7,7 +7,7 @@ from langtrace_python_sdk.utils.with_root_span import (
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init()
+langtrace.init(write_to_langtrace_cloud=True)
 client = OpenAI()
 
 

examples/openai/function_calling.py

@@ -8,7 +8,7 @@ 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)
+langtrace.init(write_to_langtrace_cloud=False)
 
 client = OpenAI()
 

examples/perplexity_example/basic.py

@@ -2,11 +2,13 @@ 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)
+    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)
+langtrace.init(write_to_langtrace_cloud=False)
 client = OpenAI(base_url="https://api.perplexity.ai", api_key="PPLX_API_KEY")
 
 
@@ -18,4 +20,4 @@ def basic():
         stream=False,
     )
     print(response)
-    return response
+    return response

examples/pinecone_example/basic.py

@@ -11,7 +11,7 @@ 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)
+langtrace.init(write_to_langtrace_cloud=False)
 
 client = OpenAI()
 pinecone = Pinecone()

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,7 @@ SERVICE_PROVIDERS = {
     "LLAMAINDEX": "LlamaIndex",
     "OPENAI": "OpenAI",
     "PINECONE": "Pinecone",
+    "COHERE": "Cohere",
     "PPLX": "Perplexity",
 }
 

langtrace_python_sdk/extensions/langtrace_exporter.py

@@ -6,7 +6,9 @@ import requests
 from opentelemetry.sdk.trace.export import ReadableSpan, SpanExporter, SpanExportResult
 from opentelemetry.trace.span import format_trace_id
 
-from langtrace_python_sdk.constants.exporter.langtrace_exporter import LANGTRACE_REMOTE_URL
+from langtrace_python_sdk.constants.exporter.langtrace_exporter import (
+    LANGTRACE_REMOTE_URL,
+)
 
 
 class LangTraceExporter(SpanExporter):
@@ -48,7 +50,12 @@ class LangTraceExporter(SpanExporter):
     api_key: str
     write_to_remote_url: bool
 
-    def __init__(self, api_key: str = None, write_to_remote_url: bool = False, api_host: typing.Optional[str] = None) -> None:
+    def __init__(
+        self,
+        api_key: str = None,
+        write_to_remote_url: bool = False,
+        api_host: typing.Optional[str] = None,
+    ) -> None:
         self.api_key = api_key or os.environ.get("LANGTRACE_API_KEY")
         self.write_to_remote_url = write_to_remote_url
         self.api_host: str = api_host or LANGTRACE_REMOTE_URL
@@ -89,6 +96,7 @@ class LangTraceExporter(SpanExporter):
                 data=json.dumps(data),
                 headers={"Content-Type": "application/json", "x-api-key": self.api_key},
             )
+            print(f"sent to {self.api_host}/api/trace with {len(data)} spans")
             return SpanExportResult.SUCCESS
         except Exception as e:
             return SpanExportResult.FAILURE

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