langwatch 0.2.10__tar.gz → 0.2.11__tar.gz

{langwatch-0.2.10 → langwatch-0.2.11}/Makefile

@@ -42,6 +42,8 @@ ensure-openapi-python-client:
 	fi
 
 generate/api-client: ensure-openapi-python-client
+	@echo "Deleting old API client..."
+	@rm -rf src/langwatch/generated/langwatch_rest_api_client
 	@echo "Building API client..."
 	@mkdir -p .tmp/api-client
 	uv run openapi-python-client generate \

{langwatch-0.2.10 → langwatch-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch
-Version: 0.2.10
+Version: 0.2.11
 Summary: LangWatch Python SDK, for monitoring your LLMs
 Author-email: Langwatch Engineers <engineering@langwatch.ai>
 License: MIT
@@ -9,12 +9,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: !=3.9.7,<3.13,>=3.9
+Requires-Python: <3.13,>=3.10
 Requires-Dist: coolname>=2.2.0
 Requires-Dist: deprecated>=1.2.18
 Requires-Dist: dspy-ai<3.0.0,>=2.5.2
@@ -27,7 +26,9 @@ Requires-Dist: openinference-instrumentation-openai>=0.1.25
 Requires-Dist: openinference-semantic-conventions>=0.1.17
 Requires-Dist: opentelemetry-api>=1.32.1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.32.1
+Requires-Dist: opentelemetry-instrumentation-crewai>=0.45.0
 Requires-Dist: opentelemetry-sdk>=1.32.1
+Requires-Dist: python-liquid>=2.0.2
 Requires-Dist: retry>=0.9.2
 Requires-Dist: termcolor>=3.0.1
 Provides-Extra: dev
@@ -35,6 +36,7 @@ Requires-Dist: ruff>=0.11.1; extra == 'dev'
 Provides-Extra: dspy
 Requires-Dist: dspy-ai<3.0.0,>=2.5.2; extra == 'dspy'
 Provides-Extra: tests
+Requires-Dist: factory-boy<4.0.0,>=3.3.0; extra == 'tests'
 Requires-Dist: pytest-asyncio<0.22.0,>=0.21.1; extra == 'tests'
 Requires-Dist: pytest<8.0.0,>=7.4.2; extra == 'tests'
 Description-Content-Type: text/markdown

langwatch-0.2.11/examples/opentelemetry/openllmetry_crewai_bot.py

@@ -0,0 +1,143 @@
+"""
+CrewAI Integration Examples with OpenLLMetry and LangWatch
+
+This file demonstrates how to integrate CrewAI with LangWatch using OpenLLMetry instrumentation.
+
+Installation Requirements:
+    pip install crewai
+    pip install opentelemetry-instrumentation-crewai
+    pip install langwatch
+
+For more information, see: https://docs.langwatch.ai/integration/python/integrations/crew-ai
+"""
+
+import os
+from dotenv import load_dotenv
+
+import langwatch
+import chainlit as cl
+
+load_dotenv()
+
+from opentelemetry.instrumentation.crewai import CrewAIInstrumentor
+
+# Setup LangWatch with OpenLLMetry CrewAI instrumentor
+langwatch.setup(instrumentors=[CrewAIInstrumentor()])
+
+
+# Example CrewAI agents and tasks
+def create_planning_crew():
+    """Create a planning crew for event organization"""
+    try:
+        from crewai import Agent, Task, Crew
+
+        planner = Agent(
+            role="Event Planner",
+            goal="Plan an engaging tech conference",
+            backstory="An experienced planner with a passion for technology events.",
+        )
+        task_planner = Task(
+            description="Outline the agenda for a 3-day AI conference.",
+            agent=planner,
+            expected_output="A detailed 3-day conference agenda with session topics, speakers, and timing.",
+        )
+        conference_crew = Crew(agents=[planner], tasks=[task_planner])
+        return conference_crew
+
+    except ImportError as e:
+        return None
+
+
+def create_market_analysis_crew():
+    """Create a market analysis crew"""
+    try:
+        from crewai import Agent, Task, Crew
+
+        researcher = Agent(
+            role="Market Analyst",
+            goal="Analyze market trends in AI",
+            backstory="A skilled analyst with deep understanding of technology markets.",
+        )
+        task_analyst = Task(
+            description="Analyze current AI market trends and provide insights.",
+            agent=researcher,
+            expected_output="A comprehensive market analysis report with key trends, insights, and recommendations.",
+        )
+        analysis_crew = Crew(agents=[researcher], tasks=[task_analyst])
+        return analysis_crew
+
+    except ImportError as e:
+        return None
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Main chainlit handler for CrewAI examples"""
+    msg = cl.Message(content="")
+
+    # Check if CrewAI is available
+    try:
+        import crewai
+    except ImportError:
+        await msg.stream_token(
+            "❌ CrewAI is not installed. Please install it with: pip install crewai"
+        )
+        await msg.update()
+        return
+
+    # Check if OpenLLMetry instrumentation is available
+    try:
+        from opentelemetry.instrumentation.crewai import CrewAIInstrumentor
+    except ImportError:
+        await msg.stream_token(
+            "❌ OpenLLMetry CrewAI instrumentation is not installed. Please install it with: pip install opentelemetry-instrumentation-crewai"
+        )
+        await msg.update()
+        return
+
+    await msg.stream_token(
+        "🤖 Setting up CrewAI with OpenLLMetry instrumentation...\n\n"
+    )
+
+    # Create and run the planning crew
+    await msg.stream_token("📅 Creating event planning crew...\n")
+    planning_crew = create_planning_crew()
+
+    if planning_crew is None:
+        await msg.stream_token(
+            "❌ Failed to create planning crew. Please check your CrewAI installation.\n"
+        )
+        await msg.update()
+        return
+
+    await msg.stream_token("📝 Planning crew created successfully!\n")
+    await msg.stream_token("🚀 Starting conference planning process...\n\n")
+
+    # Run the crew with LangWatch tracing
+    with langwatch.trace(name="CrewAI Planning Process with OpenLLMetry"):
+        try:
+            result = planning_crew.kickoff()
+            await msg.stream_token(
+                f"✅ Conference planning completed!\n\n📊 Results:\n{result}\n"
+            )
+        except Exception as e:
+            await msg.stream_token(f"❌ Error during planning: {str(e)}\n")
+
+    await msg.stream_token(
+        "\n🎯 This example demonstrates CrewAI integration with OpenLLMetry instrumentation via LangWatch.\n"
+    )
+    await msg.stream_token(
+        "📈 All agent interactions, task executions, and LLM calls are automatically traced and can be viewed in your LangWatch dashboard.\n"
+    )
+
+    await msg.update()
+
+
+@cl.on_chat_start
+async def on_chat_start():
+    """Initialize the chat session"""
+    await cl.Message(
+        content="🤖 Welcome to CrewAI with OpenLLMetry! This example demonstrates how CrewAI agents work with LangWatch telemetry.\n\n"
+        "💡 Ask any question to see the planning crew in action, or just say 'hello' to get started!\n\n"
+        "📅 The crew will plan a tech conference agenda, with all operations automatically traced."
+    ).send()

langwatch-0.2.11/examples/prompt_management_fastapi.py

@@ -0,0 +1,112 @@
+"""
+Example demonstrating LangWatch prompt management operations.
+
+This example shows how to:
+1. Create a new prompt
+2. Retrieve and use a prompt
+3. Update a prompt
+4. Use the updated prompt
+5. Delete a prompt
+
+Run this example with:
+    python examples/prompt_management.py
+"""
+
+from dotenv import load_dotenv
+import langwatch
+import uuid
+from openai import OpenAI
+
+load_dotenv()
+
+client = OpenAI()
+
+# Initialize LangWatch (ensure you have LANGWATCH_API_KEY set)
+langwatch.setup(debug=True)
+
+
+@langwatch.span()
+def example():
+    # Autotrack OpenAI calls
+    langwatch.get_current_trace().autotrack_openai_calls(client)
+
+    print("=== LangWatch Prompt Management Example ===\n")
+
+    # 1. Create a new prompt
+    print("1. Creating a new prompt...")
+    short_uuid = str(uuid.uuid4())[:8]
+    prompt = langwatch.prompts.create(
+        handle=f"something/example_prompt_{short_uuid}",
+        scope="PROJECT",  # optional - 'ORGANIZATION' or 'PROJECT'
+        author_id=None,  # optional
+        prompt="You are a helpful assistant. Specialize in {{subject}}.",  # optional
+        messages=[  # optional -- you cannot set a system message and a prompt at the same time
+            {"role": "user", "content": "{{question}}"},
+        ],
+        inputs=[{"identifier": "question", "type": "str"}],  # optional
+        outputs=[
+            {"identifier": "answer", "type": "str", "json_schema": {"type": "str"}}
+        ],  # optional
+    )
+    print(f"Created prompt with id: {prompt.id}")
+    print(f"Created prompt with handle: {prompt.handle}")
+
+    # 2. Get and use the prompt
+    print("2. Retrieving the prompt...")
+    retrieved_prompt = langwatch.prompts.get(prompt.handle)
+    print(f"Retrieved prompt: {retrieved_prompt.handle}")
+
+    # Use the prompt (example usage)
+    print("Using the prompt...")
+
+    # Compile the prompt with variables
+    compiled_prompt = retrieved_prompt.compile(
+        question="What is the capital of France?"
+    )
+    print(f"Compiled prompt: {compiled_prompt.prompt}")
+    print(f"Compiled prompt messages: {compiled_prompt.messages}")
+
+    # 3. Update the prompt
+    print("3. Updating the prompt...")
+    updated_prompt = langwatch.prompts.update(
+        prompt.handle,
+        handle=f"updated_example_prompt_{short_uuid}",  # optional
+        scope="PROJECT",  # optional - 'ORGANIZATION' or 'PROJECT'
+        prompt="You are obsessed with {{subject}} and talk in CAPS.",  # optional
+    )
+    print(f"Updated prompt name: {updated_prompt.name}")
+    print(f"Prompt ID remains: {updated_prompt.id}")
+
+    # 4. Use the updated prompt
+    print("Using the updated prompt...")
+
+    # Compile the updated prompt to show the difference
+    updated_compiled = updated_prompt.compile_strict(
+        subject="quantum computing", question="How does it work in 10 words or less?"
+    )
+    print(f"Updated compiled prompt: {updated_compiled.prompt}")
+    print(f"Updated compiled prompt messages: {updated_compiled.messages}")
+
+    # This is where you would use the prompt in your application
+    # For example, you could use the prompt to generate a response
+    response = client.chat.completions.create(
+        model=updated_compiled.model.split("openai/")[1],
+        messages=updated_compiled.messages,
+    )
+
+    print(f"Response: {response.choices[0].message.content}")
+
+    # 5. Delete the prompt
+    print("5. Deleting the prompt...")
+    result = langwatch.prompts.delete(updated_prompt.handle)
+    print(f"Deletion result: {result}")
+    print("Prompt management example completed successfully!")
+
+
+@langwatch.trace()
+def main():
+    example()
+
+
+if __name__ == "__main__":
+    main()

{langwatch-0.2.10 → langwatch-0.2.11}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "langwatch"
-version = "0.2.10" # remember to also update it in src/langwatch/__version__.py
+version = "0.2.11" # remember to also update it in src/langwatch/__version__.py
 description = "LangWatch Python SDK, for monitoring your LLMs"
 authors = [{ name = "Langwatch Engineers", email = "engineering@langwatch.ai" }]
-requires-python = ">=3.9,<3.13,!=3.9.7"
+requires-python = ">=3.10,<3.13"
 license = { text = "MIT" }
 readme = "README.md"
 classifiers = [
@@ -12,7 +12,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
+
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -32,15 +32,17 @@ dependencies = [
     "opentelemetry-api>=1.32.1",
     "opentelemetry-exporter-otlp-proto-http>=1.32.1",
     "opentelemetry-sdk>=1.32.1",
+    "opentelemetry-instrumentation-crewai>=0.45.0",
     "retry>=0.9.2",
     "termcolor>=3.0.1",
     "deprecated>=1.2.18",
+    "python-liquid>=2.0.2",
 ]
 
 [project.optional-dependencies]
 dspy = ["dspy-ai>=2.5.2,<3.0.0"]
 dev = ["ruff>=0.11.1"]
-tests = ["pytest>=7.4.2,<8.0.0", "pytest-asyncio>=0.21.1,<0.22.0"]
+tests = ["pytest>=7.4.2,<8.0.0", "pytest-asyncio>=0.21.1,<0.22.0", "factory-boy>=3.3.0,<4.0.0"]
 
 [build-system]
 requires = ["hatchling"]

{langwatch-0.2.10 → langwatch-0.2.11}/src/langwatch/__init__.py

@@ -12,12 +12,18 @@ from .utils.initialization import ensure_setup, setup
 # Type hints for IntelliSense (only imported for typing)
 from typing import TYPE_CHECKING
 
+# Type hints for IntelliSense (only imported for typing)
 if TYPE_CHECKING:
     import langwatch.evaluations as evaluations
     import langwatch.evaluation as evaluation
     import langwatch.dataset as dataset
     import langwatch.dspy as dspy
     import langwatch.langchain as langchain
+    from .prompts.service import PromptService
+
+    # Type hint for the prompts service specifically
+    # required to get the instance typing correct
+    prompts: PromptService
 
 
 @module_property
@@ -54,6 +60,13 @@ def __getattr__(name: str):
             # Cache it in the module globals for subsequent access
             globals()[name] = module
             return module
+    elif name == "prompts":
+        # Special-case: expose a PromptService instance at langwatch.prompts
+        from .prompts.service import PromptService
+
+        svc = PromptService.from_global()
+        globals()[name] = svc  # Cache for subsequent access
+        return svc
 
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
@@ -140,4 +153,5 @@ __all__ = [
     "evaluations",
     "langchain",
     "dspy",
+    "prompts",
 ]

{langwatch-0.2.10 → langwatch-0.2.11}/src/langwatch/__version__.py

@@ -1,3 +1,3 @@
 """Version information for LangWatch."""
 
-__version__ = "0.2.10"
+__version__ = "0.2.11"

{langwatch-0.2.10 → langwatch-0.2.11}/src/langwatch/attributes.py

@@ -72,9 +72,13 @@ class AttributeKey:
     LangWatchEventEvaluationCustom = "langwatch.evaluation.custom"
     LangWatchEventEvaluationLog = "langwatch.evaluation.log"
 
+    # LangWatch Prompt attributes
     LangWatchPromptId = "langwatch.prompt.id"
+    LangWatchPromptHandle = "langwatch.prompt.handle"
     LangWatchPromptVersionId = "langwatch.prompt.version.id"
     LangWatchPromptVersionNumber = "langwatch.prompt.version.number"
+    LangWatchPromptVariables = "langwatch.prompt.variables"
+    LangWatchPromptSelectedId = "langwatch.prompt.selected.id"
 
     # Deprecated attributes
     DeprecatedTraceId = "deprecated.trace.id"

{langwatch-0.2.10 → langwatch-0.2.11}/src/langwatch/batch_evaluation.py

@@ -108,6 +108,7 @@ class BatchEvaluation:
         experiment: Optional[str] = None,
         run_id: Optional[str] = None,
         max_workers=4,
+        settings: Optional[dict[str, Any]] = None,
     ):
         self.dataset = dataset
         self.evaluations = evaluations
@@ -119,7 +120,7 @@ class BatchEvaluation:
         self.total = 0
         self.progress = 0
         self.created_at = int(time.time() * 1000)
-
+        self.settings = settings or {}
         self.lock = threading.Lock()
         self.batch = {"dataset": [], "evaluations": []}
         self.last_sent = 0
@@ -244,7 +245,9 @@ class BatchEvaluation:
 
         coroutines: list[Coroutine[Tuple[str, SingleEvaluationResult], Any, Any]] = []
         for evaluation in self.evaluations:
-            coroutines.append(run_evaluation(entry_with_output, evaluation, error))
+            coroutines.append(
+                run_evaluation(entry_with_output, evaluation, error, self.settings)
+            )
 
         async def gather_results(futures):
             evaluation_results = await asyncio.gather(*futures)
@@ -331,6 +334,7 @@ class BatchEvaluation:
                 "evaluations": self.batch["evaluations"],
                 "progress": self.progress,
                 "total": self.total,
+                "settings": self.settings,
                 "timestamps": {
                     "created_at": self.created_at,
                 },
@@ -382,6 +386,7 @@ async def run_evaluation(
     data: DatasetEntry,
     evaluation: str,
     error: Optional[Exception] = None,
+    settings: Optional[Dict[str, Any]] = None,
 ) -> Tuple[str, SingleEvaluationResult]:
     if error:
         return evaluation, EvaluationResultSkipped(
@@ -395,6 +400,10 @@ async def run_evaluation(
             "data": data.model_dump(),
         }
 
+        # Include settings if provided
+        if settings:
+            json_data["settings"] = settings
+
         request_params = {
             "url": langwatch.get_endpoint() + f"/api/evaluations/{evaluation}/evaluate",
             "headers": {"X-Auth-Token": langwatch.get_api_key()},

langwatch-0.2.11/src/langwatch/generated/langwatch_rest_api_client/api/default/delete_api_scenario_events.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.delete_api_scenario_events_response_200 import DeleteApiScenarioEventsResponse200
+from ...models.delete_api_scenario_events_response_400 import DeleteApiScenarioEventsResponse400
+from ...models.delete_api_scenario_events_response_401 import DeleteApiScenarioEventsResponse401
+from ...models.delete_api_scenario_events_response_500 import DeleteApiScenarioEventsResponse500
+from ...types import Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/scenario-events",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    if response.status_code == 200:
+        response_200 = DeleteApiScenarioEventsResponse200.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = DeleteApiScenarioEventsResponse400.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = DeleteApiScenarioEventsResponse401.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = DeleteApiScenarioEventsResponse500.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    """Delete all events
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[DeleteApiScenarioEventsResponse200, DeleteApiScenarioEventsResponse400, DeleteApiScenarioEventsResponse401, DeleteApiScenarioEventsResponse500]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    """Delete all events
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[DeleteApiScenarioEventsResponse200, DeleteApiScenarioEventsResponse400, DeleteApiScenarioEventsResponse401, DeleteApiScenarioEventsResponse500]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    """Delete all events
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[DeleteApiScenarioEventsResponse200, DeleteApiScenarioEventsResponse400, DeleteApiScenarioEventsResponse401, DeleteApiScenarioEventsResponse500]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[
+    Union[
+        DeleteApiScenarioEventsResponse200,
+        DeleteApiScenarioEventsResponse400,
+        DeleteApiScenarioEventsResponse401,
+        DeleteApiScenarioEventsResponse500,
+    ]
+]:
+    """Delete all events
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[DeleteApiScenarioEventsResponse200, DeleteApiScenarioEventsResponse400, DeleteApiScenarioEventsResponse401, DeleteApiScenarioEventsResponse500]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed