langtrace-python-sdk 2.3.2__tar.gz → 2.3.4__tar.gz

{langtrace_python_sdk-2.3.2 → langtrace_python_sdk-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.3.2
+Version: 2.3.4
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>

{langtrace_python_sdk-2.3.2 → langtrace_python_sdk-2.3.4}/src/examples/anthropic_example/completion.py

@@ -7,7 +7,7 @@ from langtrace_python_sdk import langtrace, with_langtrace_root_span
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init()
+langtrace.init(write_spans_to_console=True)
 
 
 @with_langtrace_root_span("messages_create")

langtrace_python_sdk-2.3.4/src/examples/crewai_example/instagram_post/agents.py

@@ -0,0 +1,96 @@
+from crewai import Agent
+from tools.browser_tools import scrape_and_summarize_website
+from langchain_openai import ChatOpenAI
+# from langchain.llms import Ollama
+
+
+class MarketingAnalysisAgents:
+    def __init__(self):
+        # self.llm = Ollama(model=os.environ["MODEL"])
+        self.llm = ChatOpenAI(model_name="gpt-4", temperature=0.7)
+
+    def product_competitor_agent(self):
+        return Agent(
+            role="Lead Market Analyst",
+            goal="""\
+                Conduct amazing analysis of the products and
+                competitors, providing in-depth insights to guide
+                marketing strategies.""",
+            backstory="""\
+                As the Lead Market Analyst at a premier
+                digital marketing firm, you specialize in dissecting
+                online business landscapes.""",
+            tools=[scrape_and_summarize_website],
+            allow_delegation=False,
+            llm=self.llm,
+            verbose=True,
+        )
+
+    def strategy_planner_agent(self):
+        return Agent(
+            role="Chief Marketing Strategist",
+            goal="""\
+                Synthesize amazing insights from product analysis
+                to formulate incredible marketing strategies.""",
+            backstory="""\
+                You are the Chief Marketing Strategist at
+                a leading digital marketing agency, known for crafting
+                bespoke strategies that drive success.""",
+            tools=[scrape_and_summarize_website],
+            llm=self.llm,
+            verbose=True,
+        )
+
+    def creative_content_creator_agent(self):
+        return Agent(
+            role="Creative Content Creator",
+            goal="""\
+                Develop compelling and innovative content
+                for social media campaigns, with a focus on creating
+                high-impact Instagram ad copies.""",
+            backstory="""\
+                As a Creative Content Creator at a top-tier
+                digital marketing agency, you excel in crafting narratives
+                that resonate with audiences on social media.
+                Your expertise lies in turning marketing strategies
+                into engaging stories and visual content that capture
+                attention and inspire action.""",
+            tools=[scrape_and_summarize_website],
+            llm=self.llm,
+            verbose=True,
+        )
+
+    def senior_photographer_agent(self):
+        return Agent(
+            role="Senior Photographer",
+            goal="""\
+            Take the most amazing photographs for instagram ads that
+            capture emotions and convey a compelling message.""",
+            backstory="""\
+            As a Senior Photographer at a leading digital marketing
+            agency, you are an expert at taking amazing photographs that
+            inspire and engage, you're now working on a new campaign for a super
+            important customer and you need to take the most amazing photograph.""",
+            tools=[scrape_and_summarize_website],
+            llm=self.llm,
+            allow_delegation=False,
+            verbose=True,
+        )
+
+    def chief_creative_diretor_agent(self):
+        return Agent(
+            role="Chief Creative Director",
+            goal="""\
+                Oversee the work done by your team to make sure it's the best
+                possible and aligned with the product's goals, review, approve,
+                ask clarifying question or delegate follow up work if necessary to make
+                decisions""",
+            backstory="""\
+                You're the Chief Content Officer of leading digital
+                marketing specialized in product branding. You're working on a new
+                customer, trying to make sure your team is crafting the best possible
+                content for the customer.""",
+            tools=[scrape_and_summarize_website],
+            llm=self.llm,
+            verbose=True,
+        )

langtrace_python_sdk-2.3.4/src/examples/crewai_example/instagram_post/main.py

@@ -0,0 +1,80 @@
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+from langtrace_python_sdk import langtrace
+
+langtrace.init()
+
+from crewai import Crew
+from agents import MarketingAnalysisAgents
+from tasks import MarketingAnalysisTasks
+
+tasks = MarketingAnalysisTasks()
+agents = MarketingAnalysisAgents()
+
+print("## Welcome to the marketing Crew")
+print('-------------------------------')
+product_website = "https://langtrace.ai"
+product_details = "LLM App monitoring"
+
+
+# Create Agents
+product_competitor_agent = agents.product_competitor_agent()
+# strategy_planner_agent = agents.strategy_planner_agent()
+# creative_agent = agents.creative_content_creator_agent()
+# # Create Tasks
+website_analysis = tasks.product_analysis(product_competitor_agent, product_website, product_details)
+# market_analysis = tasks.competitor_analysis(product_competitor_agent, product_website, product_details)
+# campaign_development = tasks.campaign_development(strategy_planner_agent, product_website, product_details)
+# write_copy = tasks.instagram_ad_copy(creative_agent)
+
+# Create Crew responsible for Copy
+copy_crew = Crew(
+    agents=[
+        product_competitor_agent,
+        # strategy_planner_agent,
+        # creative_agent
+    ],
+    tasks=[
+        website_analysis,
+        # market_analysis,
+        # campaign_development,
+        # write_copy
+    ],
+    verbose=True
+)
+
+ad_copy = copy_crew.kickoff()
+
+# Create Crew responsible for Image
+# senior_photographer = agents.senior_photographer_agent()
+# chief_creative_diretor = agents.chief_creative_diretor_agent()
+# # Create Tasks for Image
+# take_photo = tasks.take_photograph_task(senior_photographer, ad_copy, product_website, product_details)
+# approve_photo = tasks.review_photo(chief_creative_diretor, product_website, product_details)
+
+# image_crew = Crew(
+#     agents=[
+#         senior_photographer,
+#         chief_creative_diretor
+#     ],
+#     tasks=[
+#         take_photo,
+#         approve_photo
+#     ],
+#     verbose=True
+# )
+
+# image = image_crew.kickoff()
+
+# Print results
+print("\n\n########################")
+print("## Here is the result")
+print("########################\n")
+print("Your post copy:")
+print(ad_copy)
+# print("'\n\nYour midjourney description:")
+# print(image)

langtrace_python_sdk-2.3.4/src/examples/crewai_example/instagram_post/tasks.py

@@ -0,0 +1,146 @@
+from crewai import Task
+from textwrap import dedent
+
+
+class MarketingAnalysisTasks:
+    def product_analysis(self, agent, product_website, product_details):
+        return Task(
+            description=dedent(
+                f"""\
+            Analyze the given product website: {product_website}.
+            Extra details provided by the customer: {product_details}.
+
+            Focus on identifying unique features, benefits,
+            and the overall narrative presented.
+
+            Your final report should clearly articulate the
+            product's key selling points, its market appeal,
+            and suggestions for enhancement or positioning.
+            Emphasize the aspects that make the product stand out.
+
+            Keep in mind, attention to detail is crucial for
+            a comprehensive analysis. It's currenlty 2024.
+            """
+            ),
+            agent=agent,
+            expected_output="A detailed analysis of the product website, highlighting key features, benefits, and market positioning.",
+        )
+
+    def competitor_analysis(self, agent, product_website, product_details):
+        return Task(
+            description=dedent(
+                f"""\
+            Explore competitor of: {product_website}.
+            Extra details provided by the customer: {product_details}.
+
+            Identify the top 3 competitors and analyze their
+            strategies, market positioning, and customer perception.
+
+            Your final report MUST include BOTH all context about {product_website}
+            and a detailed comparison to whatever competitor they have competitors.
+            """
+            ),
+            agent=agent,
+            expected_output="A comprehensive analysis of the top 3 competitors, including their strategies, market positioning, and customer perception.",
+        )
+
+    def campaign_development(self, agent, product_website, product_details):
+        return Task(
+            description=dedent(
+                f"""\
+            You're creating a targeted marketing campaign for: {product_website}.
+            Extra details provided by the customer: {product_details}.
+
+            To start this campaing we will need a strategy and creative content ideas.
+            It should be meticulously designed to captivate and engage
+            the product's target audience.
+
+            Based on your ideas your co-workers will create the content for the campaign.
+
+            Your final answer MUST be ideas that will resonate with the audience and
+            also include ALL context you have about the product and the customer.
+            """
+            ),
+            agent=agent,
+            expected_output="A detailed marketing campaign strategy, including creative content ideas and target audience analysis.",
+        )
+
+    def instagram_ad_copy(self, agent):
+        return Task(
+            description=dedent(
+                """\
+            Craft an engaging Instagram post copy.
+            The copy should be punchy, captivating, concise,
+            and aligned with the product marketing strategy.
+
+            Focus on creating a message that resonates with
+            the target audience and highlights the product's
+            unique selling points.
+
+            Your ad copy must be attention-grabbing and should
+            encourage viewers to take action, whether it's
+            visiting the website, making a purchase, or learning
+            more about the product.
+
+            Your final answer MUST be 3 options for an ad copy for instagram that
+            not only informs but also excites and persuades the audience.
+            """
+            ),
+            agent=agent,
+            expected_output="Three engaging Instagram ad copies that align with the product marketing strategy.",
+        )
+
+    def take_photograph_task(self, agent, copy, product_website, product_details):
+        return Task(
+            description=dedent(
+                f"""\
+            You are working on a new campaign for a super important customer,
+            and you MUST take the most amazing photo ever for an instagram post
+            regarding the product, you have the following copy:
+            {copy}
+
+            This is the product you are working with: {product_website}.
+            Extra details provided by the customer: {product_details}.
+
+            Imagine what the photo you wanna take describe it in a paragraph.
+            Here are some examples for you follow:
+            - high tech airplaine in a beautiful blue sky in a beautiful sunset super cripsy beautiful 4k, professional wide shot
+            - the last supper, with Jesus and his disciples, breaking bread, close shot, soft lighting, 4k, crisp
+            - an bearded old man in the snows, using very warm clothing, with mountains full of snow behind him, soft lighting, 4k, crisp, close up to the camera
+
+            Think creatively and focus on how the image can capture the audience's
+            attention. Don't show the actual product on the photo.
+
+            Your final answer must be 3 options of photographs, each with 1 paragraph
+            describing the photograph exactly like the examples provided above.
+            """
+            ),
+            agent=agent,
+            expected_output="Three high-quality photographs that creatively capture the essence of the product and engage the audience.",
+        )
+
+    def review_photo(self, agent, product_website, product_details):
+        return Task(
+            description=dedent(
+                f"""\
+            Review the photos you got from the senior photographer.
+            Make sure it's the best possible and aligned with the product's goals,
+            review, approve, ask clarifying question or delegate follow up work if
+            necessary to make decisions. When delegating work send the full draft
+            as part of the information.
+
+            This is the product you are working with: {product_website}.
+            Extra details provided by the customer: {product_details}.
+
+            Here are some examples on how the final photographs should look like:
+            - high tech airplaine in a beautiful blue sky in a beautiful sunset super cripsy beautiful 4k, professional wide shot
+            - the last supper, with Jesus and his disciples, breaking bread, close shot, soft lighting, 4k, crisp
+            - an bearded old man in the snows, using very warm clothing, with mountains full of snow behind him, soft lighting, 4k, crisp, close up to the camera
+
+            Your final answer must be 3 reviewed options of photographs,
+            each with 1 paragraph description following the examples provided above.
+            """
+            ),
+            agent=agent,
+            expected_output="Three reviewed photographs that align with the product's goals and meet the required standards.",
+        )

langtrace_python_sdk-2.3.4/src/examples/crewai_example/instagram_post/tools/browser_tools.py

@@ -0,0 +1,40 @@
+import json
+import os
+
+import requests
+from crewai import Agent, Task
+from crewai_tools import tool
+from unstructured.partition.html import partition_html
+
+from langchain_openai import ChatOpenAI
+
+
+@tool
+def scrape_and_summarize_website(website):
+    """Useful to scrape and summarize a website content, just pass a string with
+    only the full url, no need for a final slash `/`, eg: https://google.com or https://clearbit.com/about-us"""
+    url = f"https://chrome.browserless.io/content?token={os.environ['BROWSERLESS_API_KEY']}"
+    payload = json.dumps({"url": website})
+    headers = {'cache-control': 'no-cache', 'content-type': 'application/json'}
+    response = requests.request("POST", url, headers=headers, data=payload)
+    elements = partition_html(text=response.text)
+    content = "\n\n".join([str(el) for el in elements])
+    content = [content[i:i + 8000] for i in range(0, len(content), 8000)]
+    summaries = []
+    for chunk in content:
+        agent = Agent(
+            role='Principal Researcher',
+            goal='Do amazing researches and summaries based on the content you are working with',
+            backstory="You're a Principal Researcher at a big company and you need to do a research about a given topic.",
+            # llm=Ollama(model=os.environ['MODEL']),
+            llm=ChatOpenAI(model_name="gpt-4", temperature=0.7),
+            allow_delegation=False)
+        task = Task(
+            agent=agent,
+            description=f'Analyze and make a LONG summary the content bellow, make sure to include the ALL relevant information in the summary, return only the summary nothing else.\n\nCONTENT\n----------\n{chunk}',
+            expected_output='A long summary of the content',
+        )
+        summary = task.execute_sync()
+        summaries.append(summary)
+        content = "\n\n".join(summaries)
+    return f'\nScrapped Content: {content}\n'

{langtrace_python_sdk-2.3.2 → langtrace_python_sdk-2.3.4}/src/examples/openai_example/__init__.py

@@ -20,3 +20,4 @@ class OpenAIRunner:
         chat_completion_example()
         embeddings_create_example()
         function_example()
+        image_edit()

{langtrace_python_sdk-2.3.2 → langtrace_python_sdk-2.3.4}/src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py

@@ -16,38 +16,39 @@ limitations under the License.
 
 import importlib.metadata
 import logging
-from typing import Collection
+from typing import Collection, Any
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import TracerProvider
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
-
+from typing import Any
 from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
 
 logging.basicConfig(level=logging.FATAL)
 
 
-class AnthropicInstrumentation(BaseInstrumentor):
+class AnthropicInstrumentation(BaseInstrumentor):  # type: ignore[misc]
     """
-    The AnthropicInstrumentation class represents the Anthropic instrumentation
+    The AnthropicInstrumentation class represents the Anthropic instrumentation.
     """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return ["anthropic >= 0.19.1"]
 
-    def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get("tracer_provider")
+    def _instrument(self, **kwargs: dict[str, Any]) -> None:
+        tracer_provider: TracerProvider = kwargs.get("tracer_provider")  # type: ignore
         tracer = get_tracer(__name__, "", tracer_provider)
         version = importlib.metadata.version("anthropic")
 
         wrap_function_wrapper(
             "anthropic.resources.messages",
             "Messages.create",
-            messages_create("anthropic.messages.create", version, tracer),
+            messages_create(version, tracer),
         )
 
-    def _instrument_module(self, module_name):
+    def _instrument_module(self, module_name: str) -> None:
         pass
 
-    def _uninstrument(self, **kwargs):
+    def _uninstrument(self, **kwargs: dict[str, Any]) -> None:
         pass

{langtrace_python_sdk-2.3.2 → langtrace_python_sdk-2.3.4}/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import json
-
-from langtrace.trace_attributes import Event, LLMSpanAttributes
+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
 
@@ -27,41 +26,48 @@ from langtrace_python_sdk.utils.llm import (
     get_llm_request_attributes,
     get_llm_url,
     get_span_name,
-    is_streaming,
     set_event_completion,
     set_usage_attributes,
+    set_span_attribute,
 )
-from opentelemetry.trace import SpanKind
-from opentelemetry.trace.status import Status, StatusCode
-from langtrace.trace_attributes import SpanAttributes
-
+from opentelemetry.trace import Span, Tracer, SpanKind
+from opentelemetry.trace.status import StatusCode
 from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
-from langtrace_python_sdk.constants.instrumentation.common import (
-    SERVICE_PROVIDERS,
+from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
+from langtrace_python_sdk.instrumentation.anthropic.types import (
+    StreamingResult,
+    ResultType,
+    MessagesCreateKwargs,
+    ContentItem,
+    Usage,
 )
 
 
-def messages_create(original_method, version, tracer):
+def messages_create(version: str, tracer: Tracer) -> Callable[..., Any]:
     """Wrap the `messages_create` method."""
 
-    def traced_method(wrapped, instance, args, kwargs):
+    def traced_method(
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: List[Any],
+        kwargs: MessagesCreateKwargs,
+    ) -> Any:
         service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
 
-        # extract system from kwargs and attach as a role to the prompts
-        # we do this to keep it consistent with the openai
+        # Extract system from kwargs and attach as a role to the prompts
         prompts = kwargs.get("messages", [])
         system = kwargs.get("system")
         if system:
             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"],
-            **get_extra_attributes(),
+            **extraAttributes,  # type: ignore
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
@@ -74,37 +80,35 @@ def messages_create(original_method, version, tracer):
         try:
             # Attempt to call the original method
             result = wrapped(*args, **kwargs)
-            return set_response_attributes(result, span, kwargs)
+            return set_response_attributes(result, span)
 
         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)))
+            span.set_status(StatusCode.ERROR, str(err))
             # Reraise the exception to ensure it's not swallowed
             span.end()
             raise
 
-    @silently_fail
-    def set_response_attributes(result, span, kwargs):
-        if not is_streaming(kwargs):
+    def set_response_attributes(
+        result: Union[ResultType, StreamingResult], span: Span
+    ) -> Any:
+        if not isinstance(result, Iterator):
             if hasattr(result, "content") and result.content is not None:
                 set_span_attribute(
                     span, SpanAttributes.LLM_RESPONSE_MODEL, result.model
                 )
+                content_item = result.content[0]
                 completion = [
                     {
-                        "role": result.role if result.role else "assistant",
-                        "content": result.content[0].text,
-                        "type": result.content[0].type,
+                        "role": result.role or "assistant",
+                        "content": content_item.text,
+                        "type": content_item.type,
                     }
                 ]
                 set_event_completion(span, completion)
 
-            else:
-                responses = []
-                set_event_completion(span, responses)
-
             if (
                 hasattr(result, "system_fingerprint")
                 and result.system_fingerprint is not None
@@ -116,7 +120,7 @@ def messages_create(original_method, version, tracer):
             # Get the usage
             if hasattr(result, "usage") and result.usage is not None:
                 usage = result.usage
-                set_usage_attributes(span, dict(usage))
+                set_usage_attributes(span, vars(usage))
 
             span.set_status(StatusCode.OK)
             span.end()

langtrace_python_sdk-2.3.4/src/langtrace_python_sdk/instrumentation/anthropic/types.py

@@ -0,0 +1,105 @@
+"""
+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.
+"""
+
+from typing import Dict, List, Optional, Iterator, TypedDict
+
+
+class MessagesCreateKwargs(TypedDict, total=False):
+    system: Optional[str]
+    messages: List[Dict[str, str]]
+
+
+class Usage:
+    input_tokens: int
+    output_tokens: int
+
+    def __init__(self, input_tokens: int, output_tokens: int):
+        self.input_tokens = input_tokens
+        self.output_tokens = output_tokens
+
+
+class Message:
+    def __init__(
+        self,
+        id: str,
+        model: Optional[str],
+        usage: Optional[Usage],
+    ):
+        self.id = id
+        self.model = model
+        self.usage = usage
+
+    model: Optional[str]
+    usage: Optional[Usage]
+
+
+class Delta:
+    text: Optional[str]
+
+    def __init__(
+        self,
+        text: Optional[str],
+    ):
+        self.text = text
+
+
+class Chunk:
+    message: Message
+    delta: Delta
+
+    def __init__(
+        self,
+        message: Message,
+        delta: Delta,
+    ):
+        self.message = message
+        self.delta = delta
+
+
+class ContentItem:
+    role: str
+    content: str
+    text: str
+    type: str
+
+    def __init__(self, role: str, content: str, text: str, type: str):
+        self.role = role
+        self.content = content
+        self.text = text
+        self.type = type
+
+
+class ResultType:
+    model: Optional[str]
+    role: Optional[str]
+    content: List[ContentItem]
+    system_fingerprint: Optional[str]
+    usage: Optional[Usage]
+
+    def __init__(
+        self,
+        model: Optional[str],
+        role: Optional[str],
+        content: Optional[List[ContentItem]],
+        system_fingerprint: Optional[str],
+        usage: Optional[Usage],
+    ):
+        self.model = model
+        self.role = role
+        self.content = content if content is not None else []
+        self.system_fingerprint = system_fingerprint
+        self.usage = usage
+
+
+# The result would be an iterator that yields these Chunk objects
+StreamingResult = Iterator[Chunk]