langtrace-python-sdk 2.2.30__tar.gz → 2.3.0__tar.gz

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.2.30
+Version: 2.3.0
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -26,6 +26,7 @@ Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: chromadb; extra == 'dev'
 Requires-Dist: cohere; extra == 'dev'
+Requires-Dist: embedchain; extra == 'dev'
 Requires-Dist: google-cloud-aiplatform; extra == 'dev'
 Requires-Dist: google-generativeai; extra == 'dev'
 Requires-Dist: groq; extra == 'dev'
@@ -302,6 +303,7 @@ Langtrace automatically captures traces from the following vendors:
 | Ollama       | Framework       | :x:                | :white_check_mark:              |
 | VertexAI     | Framework       | :x:                | :white_check_mark:              |
 | Vercel AI SDK| Framework       | :white_check_mark: | :x:                             |
+| EmbedChain   | Framework       | :x:                | :white_check_mark:              |
 | Pinecone     | Vector Database | :white_check_mark: | :white_check_mark:              |
 | ChromaDB     | Vector Database | :white_check_mark: | :white_check_mark:              |
 | QDrant       | Vector Database | :white_check_mark: | :white_check_mark:              |

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/README.md

@@ -255,6 +255,7 @@ Langtrace automatically captures traces from the following vendors:
 | Ollama       | Framework       | :x:                | :white_check_mark:              |
 | VertexAI     | Framework       | :x:                | :white_check_mark:              |
 | Vercel AI SDK| Framework       | :white_check_mark: | :x:                             |
+| EmbedChain   | Framework       | :x:                | :white_check_mark:              |
 | Pinecone     | Vector Database | :white_check_mark: | :white_check_mark:              |
 | ChromaDB     | Vector Database | :white_check_mark: | :white_check_mark:              |
 | QDrant       | Vector Database | :white_check_mark: | :white_check_mark:              |

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/pyproject.toml

@@ -55,6 +55,7 @@ dev = [
   "google-generativeai",
   "google-cloud-aiplatform",
   "mistralai",
+  "embedchain",
 ]
 
 test = ["pytest", "pytest-vcr", "pytest-asyncio"]

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/examples/crewai_example/simple_agent/agents.py

@@ -1,15 +1,13 @@
 from crewai import Agent
-from langchain_openai import ChatOpenAI
 from langchain_anthropic import ChatAnthropic
 from langchain_cohere import ChatCohere
 from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
 
 
 class PoetryAgents:
     def __init__(self):
-        self.open_ai = ChatOpenAI(
-            model_name="gpt-4", temperature=0.7, stream_usage=True
-        )
+        self.open_ai = ChatOpenAI(model_name="gpt-4", temperature=0.7)
         self.anthropic = ChatAnthropic(
             model_name="claude-3-5-sonnet-20240620", temperature=0.7
         )
@@ -28,5 +26,30 @@ class PoetryAgents:
             goal="""Create a poem that captures the essence of a given theme or emotion""",
             allow_delegation=False,
             verbose=True,
-            llm=self.ollama,
+            llm=self.open_ai,
+        )
+    
+    def poet_agent_2(self):
+        return Agent(
+            role="Renaissance Poet",
+            backstory="""
+                    I am a Renaissance Poet. I am well-versed in the art of poetry and have a deep appreciation for the beauty of language and expression.
+                """,
+            goal="""Create a poem that is inspired by the works of the Renaissance poets""",
+            allow_delegation=False,
+            verbose=True,
+            llm=self.open_ai,
+        )
+
+    def poet_agent_3(self):
+        return Agent(
+            role="William Shakespeare",
+            backstory="""
+                    I am william shakespeare. I am an Expert in poetry writing and creative expression.
+                    I have been writing poetry for over 10 years and have published several collections.
+                """,
+            goal="""Create a poem that is inspired by the works of William Shakespeare""",
+            allow_delegation=False,
+            verbose=True,
+            llm=self.open_ai,
         )

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/examples/crewai_example/simple_agent/main.py

@@ -1,14 +1,12 @@
+from agents import PoetryAgents
 from crewai import Crew
-from textwrap import dedent
-from .agents import PoetryAgents
-from .tasks import PoetryTasks
-from langtrace_python_sdk import langtrace
 from dotenv import load_dotenv
-import agentops
+from tasks import PoetryTasks
+
+from langtrace_python_sdk import langtrace
 
 load_dotenv()
-agentops.init()
-langtrace.init(write_spans_to_console=False, batch=False)
+langtrace.init()
 
 
 class PoetryCrew:
@@ -20,27 +18,24 @@ class PoetryCrew:
         tasks = PoetryTasks()
 
         poetry_agent = agents.create_poet_agent()
+        poetry_agent_2 = agents.poet_agent_2()
+        poetry_agent_3 = agents.poet_agent_3()
 
         create_poem = tasks.create_poem(poetry_agent, self.topic)
+        create_poem_2 = tasks.create_poem(poetry_agent_2, self.topic)
+        create_poem_3 = tasks.create_poem(poetry_agent_3, self.topic)
 
-        crew = Crew(agents=[poetry_agent], tasks=[create_poem], verbose=True)
+        crew = Crew(agents=[poetry_agent], tasks=[create_poem], verbose=True, memory=True)
         res = crew.kickoff()
         return res
 
 
 # This is the main function that you will use to run your custom crew.
+# You can run this file using `python -m src.examples.crewai_example.simple_agent.main`
 if __name__ == "__main__":
     print("## Welcome to Poetry Crew")
     print("-------------------------------")
-    topic = input(
-        dedent(
-            """
-      What topic do you want to write a poem on?
-    """
-        )
-    )
-
-    poetry_crew = PoetryCrew(topic=topic)
+    poetry_crew = PoetryCrew(topic="cold")
     result = poetry_crew.run()
     print("\n\n########################")
     print("## Here is you poem")

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/examples/crewai_example/simple_agent/tasks.py

@@ -18,4 +18,5 @@ class PoetryTasks:
             ),
             expected_output="A creative and expressive poem that captures the essence of the given topic.",
             agent=agent,
+            output_file="poem.txt",
         )

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/examples/crewai_example/trip_planner/main.py

@@ -1,5 +1,4 @@
 from crewai import Crew
-from textwrap import dedent
 from .agents import TravelAgents
 from .tasks import TravelTasks
 from langtrace_python_sdk import langtrace
@@ -59,36 +58,8 @@ class TripCrew:
 if __name__ == "__main__":
     print("## Welcome to Trip Planner Crew")
     print("-------------------------------")
-    origin = input(
-        dedent(
-            """
-      From where will you be traveling from?
-    """
-        )
-    )
-    cities = input(
-        dedent(
-            """
-      What are the cities options you are interested in visiting?
-    """
-        )
-    )
-    date_range = input(
-        dedent(
-            """
-      What is the date range you are interested in traveling?
-    """
-        )
-    )
-    interests = input(
-        dedent(
-            """
-      What are some of your high level interests and hobbies?
-    """
-        )
-    )
 
-    trip_crew = TripCrew(origin, cities, date_range, interests)
+    trip_crew = TripCrew("cairo", "marsa alam", "sep", "scuba diving")
     result = trip_crew.run()
     print("\n\n########################")
     print("## Here is you Trip Plan")

langtrace_python_sdk-2.3.0/src/examples/embedchain_example/simple.py

@@ -0,0 +1,15 @@
+from dotenv import load_dotenv
+from embedchain import App
+from langtrace_python_sdk import langtrace
+
+load_dotenv()
+langtrace.init()
+
+app = App()
+app.reset()
+app.add("https://www.forbes.com/profile/elon-musk")
+app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+res = app.query("What is the net worth of Elon Musk today?")
+print(res)
+re2 = app.search("Elon Musk")
+print(re2)

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/langtrace_python_sdk/constants/instrumentation/common.py

@@ -30,6 +30,7 @@ SERVICE_PROVIDERS = {
     "VERTEXAI": "VertexAI",
     "GEMINI": "Gemini",
     "MISTRAL": "Mistral",
+    "EMBEDCHAIN": "Embedchain",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk-2.3.0/src/langtrace_python_sdk/constants/instrumentation/embedchain.py

@@ -0,0 +1,14 @@
+APIS = {
+    "ADD": {
+        "METHOD": "embedchain.add",
+        "OPERATION": "add",
+    },
+    "QUERY": {
+        "METHOD": "embedchain.query",
+        "OPERATION": "query",
+    },
+    "SEARCH": {
+        "METHOD": "embedchain.search",
+        "OPERATION": "search",
+    },
+}

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/langtrace_python_sdk/instrumentation/__init__.py

@@ -17,12 +17,14 @@ from .dspy import DspyInstrumentation
 from .vertexai import VertexAIInstrumentation
 from .gemini import GeminiInstrumentation
 from .mistral import MistralInstrumentation
+from .embedchain import EmbedchainInstrumentation
 
 __all__ = [
     "AnthropicInstrumentation",
     "ChromaInstrumentation",
     "CohereInstrumentation",
     "CrewAIInstrumentation",
+    "EmbedchainInstrumentation",
     "GroqInstrumentation",
     "LangchainInstrumentation",
     "LangchainCommunityInstrumentation",

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/langtrace_python_sdk/instrumentation/chroma/patch.py

@@ -51,7 +51,7 @@ def collection_patch(method, version, tracer):
             "langtrace.version": v(LANGTRACE_SDK_NAME),
             "db.system": "chromadb",
             "db.operation": api["OPERATION"],
-            "db.query": json.dumps(kwargs.get("query")),
+            "db.query": json.dumps(kwargs),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 

{langtrace_python_sdk-2.2.30 → langtrace_python_sdk-2.3.0}/src/langtrace_python_sdk/instrumentation/crewai/instrumentation.py

@@ -46,7 +46,7 @@ class CrewAIInstrumentation(BaseInstrumentor):
             )
             _W(
                 "crewai.task",
-                "Task.execute",
+                "Task.execute_sync",
                 patch_crew("Task.execute", version, tracer),
             )
         except Exception as e:

langtrace_python_sdk-2.3.0/src/langtrace_python_sdk/instrumentation/crewai/patch.py

@@ -0,0 +1,245 @@
+import json
+from importlib_metadata import version as v
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.llm import get_span_name, set_span_attributes
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
+from opentelemetry import baggage
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry.trace import SpanKind, Span, Tracer
+from opentelemetry.trace.status import Status, StatusCode
+
+
+crew_properties = {
+    "tasks": "object",
+    "agents": "object",
+    "cache": "bool",
+    "process": "object",
+    "verbose": "bool",
+    "memory": "bool",
+    "embedder": "json",
+    "full_output": "bool",
+    "manager_llm": "object",
+    "manager_agent": "object",
+    "manager_callbacks": "object",
+    "function_calling_llm": "object",
+    "config": "json",
+    "id": "object",
+    "max_rpm": "int",
+    "share_crew": "bool",
+    "step_callback": "object",
+    "task_callback": "object",
+    "prompt_file": "str",
+    "output_log_file": "bool",
+}
+
+task_properties = {
+    "id": "object",
+    "used_tools": "int",
+    "tools_errors": "int",
+    "delegations": "int",
+    "i18n": "object",
+    "thread": "object",
+    "prompt_context": "object",
+    "description": "str",
+    "expected_output": "str",
+    "config": "object",
+    "callback": "str",
+    "agent": "object",
+    "context": "object",
+    "async_execution": "bool",
+    "output_json": "object",
+    "output_pydantic": "object",
+    "output_file": "object",
+    "output": "object",
+    "tools": "object",
+    "human_input": "bool",
+}
+
+agent_properties = {
+    "formatting_errors": "int",
+    "id": "object",
+    "role": "str",
+    "goal": "str",
+    "backstory": "str",
+    "cache": "bool",
+    "config": "object",
+    "max_rpm": "int",
+    "verbose": "bool",
+    "allow_delegation": "bool",
+    "tools": "object",
+    "max_iter": "int",
+    "max_execution_time": "object",
+    "agent_executor": "object",
+    "tools_handler": "object",
+    "force_answer_max_iterations": "int",
+    "crew": "object",
+    "cache_handler": "object",
+    "step_callback": "object",
+    "i18n": "object",
+    "llm": "object",
+    "function_calling_llm": "object",
+    "callbacks": "object",
+    "system_template": "object",
+    "prompt_template": "object",
+    "response_template": "object",
+}
+
+
+def patch_crew(operation_name, version, tracer: Tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["CREWAI"]
+        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": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            get_span_name(operation_name), kind=SpanKind.CLIENT
+        ) as span:
+
+            try:
+                set_span_attributes(span, attributes)
+                CrewAISpanAttributes(span=span, instance=instance)
+                result = wrapped(*args, **kwargs)
+                if result:
+                    span.set_status(Status(StatusCode.OK))
+                    if instance.__class__.__name__ == "Crew":
+                        span.set_attribute("crewai.crew.result", str(result))
+                        if hasattr(result, "tasks_output"):
+                            span.set_attribute("crewai.crew.tasks_output", str((result.tasks_output)))
+                        if hasattr(result, "token_usage"):
+                            span.set_attribute("crewai.crew.token_usage", str((result.token_usage)))
+                        if hasattr(result, "usage_metrics"):
+                            span.set_attribute("crewai.crew.usage_metrics", str((result.usage_metrics)))
+                    elif instance.__class__.__name__ == "Agent":
+                        span.set_attribute("crewai.agent.result", str(result))
+                    elif instance.__class__.__name__ == "Task":
+                        span.set_attribute("crewai.task.result", str(result))
+
+                span.end()
+                return result
+
+            except Exception as err:
+                # Record the exception in the span
+                span.record_exception(err)
+
+                # Set the span status to indicate an error
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
+class CrewAISpanAttributes:
+    span: Span
+    crew: dict
+
+    def __init__(self, span: Span, instance) -> None:
+        self.span = span
+        self.instance = instance
+        self.crew = {
+            "tasks": [],
+            "agents": [],
+        }
+
+        self.run()
+
+    def run(self):
+        instance_name = self.instance.__class__.__name__
+        if instance_name == "Crew":
+            self.set_crew_attributes()
+            set_span_attribute(self.span, "crewai.crew.config", json.dumps(self.crew))
+
+        elif instance_name == "Agent":
+            agent = self.set_agent_attributes()
+            # for key, value in agent.items():
+            #     set_span_attribute(self.span, key, value)
+            set_span_attribute(self.span, "crewai.agent.config", json.dumps(agent))
+        elif instance_name == "Task":
+            task = self.set_task_attributes()
+            # uncomment if you want to spread attributes for the UI instead of dumping the whole object
+            # for key, value in task.items():
+            #     set_span_attribute(self.span, key, value)
+            set_span_attribute(self.span, "crewai.task.config", json.dumps(task))
+
+    def set_crew_attributes(self):
+        for key, value in self.instance.__dict__.items():
+            if key == "tasks":
+                self._parse_tasks(value)
+
+            elif key == "agents":
+                self._parse_agents(value)
+            else:
+                self.crew[key] = str(value)
+
+    def set_agent_attributes(self):
+        agent = {}
+        for key, value in self.instance.__dict__.items():
+            if value is None:
+                continue
+            agent[key] = str(value)
+
+        return agent
+
+    def set_task_attributes(self):
+        task = {}
+        for key, value in self.instance.__dict__.items():
+            if value is None:
+                continue
+
+            if key == "agent":
+                task[key] = value.role
+            else:
+                task[key] = str(value)
+        return task
+
+    def _parse_agents(self, agents):
+        for agent in agents:
+            model = None
+            if agent.llm is not None:
+                if hasattr(agent.llm, "model"):
+                    model = agent.llm.model
+                elif hasattr(agent.llm, "model_name"):
+                    model = agent.llm.model_name
+            self.crew["agents"].append(
+                {
+                    "id": str(agent.id),
+                    "role": agent.role,
+                    "goal": agent.goal,
+                    "backstory": agent.backstory,
+                    "cache": agent.cache,
+                    "config": agent.config,
+                    "verbose": agent.verbose,
+                    "allow_delegation": agent.allow_delegation,
+                    "tools": agent.tools,
+                    "max_iter": agent.max_iter,
+                    "llm": str(model if model is not None else ""),
+                }
+            )
+
+    def _parse_tasks(self, tasks):
+        for task in tasks:
+            self.crew["tasks"].append(
+                {
+                    "agent": task.agent.role,
+                    "description": task.description,
+                    "async_execution": task.async_execution,
+                    "expected_output": task.expected_output,
+                    "human_input": task.human_input,
+                    "tools": task.tools,
+                    "output_file": task.output_file,
+                }
+            )

langtrace_python_sdk-2.3.0/src/langtrace_python_sdk/instrumentation/embedchain/__init__.py

@@ -0,0 +1,5 @@
+from .instrumentation import EmbedchainInstrumentation
+
+__all__ = [
+    "EmbedchainInstrumentation",
+]

langtrace_python_sdk-2.3.0/src/langtrace_python_sdk/instrumentation/embedchain/instrumentation.py

@@ -0,0 +1,65 @@
+"""
+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.embedchain.patch import generic_patch
+
+logging.basicConfig(level=logging.FATAL)
+
+
+class EmbedchainInstrumentation(BaseInstrumentor):
+    """
+    The EmbedchainInstrumentation class represents the Embedchain instrumentation
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["embedchain >= 0.1.113"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("embedchain")
+
+        wrap_function_wrapper(
+            "embedchain.embedchain",
+            "EmbedChain.add",
+            generic_patch("ADD", version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "embedchain.embedchain",
+            "EmbedChain.query",
+            generic_patch("QUERY", version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "embedchain.embedchain",
+            "EmbedChain.search",
+            generic_patch("SEARCH", version, tracer),
+        )
+
+    def _instrument_module(self, module_name):
+        pass
+
+    def _uninstrument(self, **kwargs):
+        pass