agenta 0.19.5__tar.gz → 0.19.6a0__tar.gz

{agenta-0.19.5 → agenta-0.19.6a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.19.5
+Version: 0.19.6a0
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering

{agenta-0.19.5 → agenta-0.19.6a0}/agenta/__init__.py

@@ -14,6 +14,7 @@ from .sdk.types import (
     BinaryParam,
 )
 
+from .sdk.tracing.logger import llm_logger as logging
 from .sdk.tracing.llm_tracing import Tracing
 from .sdk.decorators.tracing import instrument
 from .sdk.decorators.llm_entrypoint import entrypoint, app

{agenta-0.19.5 → agenta-0.19.6a0}/agenta/sdk/agenta_init.py

@@ -239,6 +239,12 @@ def init(
     singleton = AgentaSingleton()
 
     singleton.init(app_id=app_id, host=host, api_key=api_key, config_fname=config_fname)
+
+    if os.environ.get("AGENTA_LOCAL", False):
+        singleton.host = singleton.host.replace(
+            "http://localhost", "http://host.docker.internal"
+        )
+
     tracing = Tracing(
         host=singleton.host,  # type: ignore
         app_id=singleton.app_id,  # type: ignore

{agenta-0.19.5 → agenta-0.19.6a0}/agenta/sdk/decorators/llm_entrypoint.py

@@ -18,6 +18,7 @@ from fastapi import Body, FastAPI, UploadFile, HTTPException
 import agenta
 from agenta.sdk.context import save_context
 from agenta.sdk.router import router as router
+from agenta.sdk.tracing.logger import llm_logger as logging
 from agenta.sdk.tracing.llm_tracing import Tracing
 from agenta.sdk.decorators.base import BaseDecorator
 from agenta.sdk.types import (
@@ -52,6 +53,12 @@ app.add_middleware(
 app.include_router(router, prefix="")
 
 
+from agenta.sdk.utils.debug import debug, DEBUG, SHIFT
+
+
+logging.setLevel("DEBUG")
+
+
 class entrypoint(BaseDecorator):
     """Decorator class to wrap a function for HTTP POST, terminal exposure and enable tracing.
 
@@ -72,6 +79,7 @@ class entrypoint(BaseDecorator):
         config_params = agenta.config.all()
         ingestible_files = self.extract_ingestible_files(func_signature)
 
+        @debug()
         @functools.wraps(func)
         async def wrapper(*args, **kwargs) -> Any:
             func_params, api_config_params = self.split_kwargs(kwargs, config_params)
@@ -79,7 +87,7 @@ class entrypoint(BaseDecorator):
             agenta.config.set(**api_config_params)
 
             # Set the configuration and environment of the LLM app parent span at run-time
-            agenta.tracing.set_span_attribute(
+            agenta.tracing.update_baggage(
                 {"config": config_params, "environment": "playground"}
             )
 
@@ -90,6 +98,7 @@ class entrypoint(BaseDecorator):
 
             return llm_result
 
+        @debug()
         @functools.wraps(func)
         async def wrapper_deployed(*args, **kwargs) -> Any:
             func_params = {
@@ -104,13 +113,14 @@ class entrypoint(BaseDecorator):
                 agenta.config.pull(config_name="default")
 
             # Set the configuration and environment of the LLM app parent span at run-time
-            agenta.tracing.set_span_attribute(
+            agenta.tracing.update_baggage(
                 {"config": config_params, "environment": kwargs["environment"]}
             )
 
             llm_result = await self.execute_function(
                 func, *args, params=func_params, config_params=config_params
             )
+
             return llm_result
 
         self.update_function_signature(
@@ -190,6 +200,7 @@ class entrypoint(BaseDecorator):
             """
             is_coroutine_function = inspect.iscoroutinefunction(func)
             start_time = time.perf_counter()
+
             if is_coroutine_function:
                 result = await func(*args, **func_params["params"])
             else:
@@ -410,7 +421,7 @@ class entrypoint(BaseDecorator):
         agenta.config.set(**args_config_params)
 
         # Set the configuration and environment of the LLM app parent span at run-time
-        agenta.tracing.set_span_attribute(
+        agenta.tracing.update_baggage(
             {"config": agenta.config.all(), "environment": "bash"}
         )
 

agenta-0.19.6a0/agenta/sdk/decorators/tracing.py

@@ -0,0 +1,188 @@
+# Stdlib Imports
+import inspect
+import traceback
+from functools import wraps
+from typing import Any, Callable, Optional
+
+# Own Imports
+import agenta as ag
+from agenta.sdk.decorators.base import BaseDecorator
+from agenta.sdk.tracing.logger import llm_logger as logging
+from agenta.sdk.tracing.tracing_context import tracing_context, TracingContext
+from agenta.sdk.utils.debug import debug, DEBUG, SHIFT
+
+
+logging.setLevel("DEBUG")
+
+
+class instrument(BaseDecorator):
+    """Decorator class for monitoring llm apps functions.
+
+    Args:
+        BaseDecorator (object): base decorator class
+
+    Example:
+    ```python
+        import agenta as ag
+
+        prompt_config = {"system_prompt": ..., "temperature": 0.5, "max_tokens": ...}
+
+        @ag.instrument(spankind="llm")
+        async def litellm_openai_call(prompt:str) -> str:
+            return "do something"
+
+        @ag.instrument(config=prompt_config) # spankind for parent span defaults to workflow
+        async def generate(prompt: str):
+            return ...
+    ```
+    """
+
+    def __init__(
+        self, config: Optional[dict] = None, spankind: str = "workflow"
+    ) -> None:
+        self.config = config
+        self.spankind = spankind
+        self.tracing = ag.tracing
+
+    def __call__(self, func: Callable[..., Any]):
+        is_coroutine_function = inspect.iscoroutinefunction(func)
+
+        @debug()
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            result = None
+            func_args = inspect.getfullargspec(func).args
+            input_dict = {name: value for name, value in zip(func_args, args)}
+            input_dict.update(kwargs)
+
+            async def wrapped_func(*args, **kwargs):
+
+                # logging.debug(" ".join([">..", str(tracing_context.get())]))
+
+                token = None
+                if tracing_context.get() is None:
+                    token = tracing_context.set(TracingContext())
+
+                # logging.debug(" ".join([">>.", str(tracing_context.get())]))
+
+                self.tracing.start_span(
+                    name=func.__name__,
+                    input=input_dict,
+                    spankind=self.spankind,
+                    config=self.config,
+                )
+
+                try:
+                    result = await func(*args, **kwargs)
+
+                    self.tracing.set_status(status="OK")
+                    self.tracing.end_span(
+                        outputs=(
+                            {"message": result}
+                            if not isinstance(result, dict)
+                            else result
+                        )
+                    )
+
+                    # logging.debug(" ".join(["<<.", str(tracing_context.get())]))
+
+                    if token is not None:
+                        tracing_context.reset(token)
+
+                    # logging.debug(" ".join(["<..", str(tracing_context.get())]))
+
+                    return result
+
+                except Exception as e:
+                    result = {
+                        "message": str(e),
+                        "stacktrace": traceback.format_exc(),
+                    }
+
+                    self.tracing.set_attributes(
+                        {"traceback_exception": traceback.format_exc()}
+                    )
+                    self.tracing.set_status(status="ERROR")
+                    self.tracing.end_span(outputs=result)
+
+                    # logging.debug(" ".join(["<<.", str(tracing_context.get())]))
+
+                    if token is not None:
+                        tracing_context.reset(token)
+
+                    # logging.debug(" ".join(["<..", str(tracing_context.get())]))
+
+                    raise e
+
+            return await wrapped_func(*args, **kwargs)
+
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            result = None
+            func_args = inspect.getfullargspec(func).args
+            input_dict = {name: value for name, value in zip(func_args, args)}
+            input_dict.update(kwargs)
+
+            def wrapped_func(*args, **kwargs):
+
+                # logging.debug(" ".join([">..", str(tracing_context.get())]))
+
+                token = None
+                if tracing_context.get() is None:
+                    token = tracing_context.set(TracingContext())
+
+                # logging.debug(" ".join([">>.", str(tracing_context.get())]))
+
+                span = self.tracing.start_span(
+                    name=func.__name__,
+                    input=input_dict,
+                    spankind=self.spankind,
+                    config=self.config,
+                )
+
+                try:
+                    result = func(*args, **kwargs)
+
+                    self.tracing.set_status(status="OK")
+                    self.tracing.end_span(
+                        outputs=(
+                            {"message": result}
+                            if not isinstance(result, dict)
+                            else result
+                        )
+                    )
+
+                    # logging.debug(" ".join(["<<.", str(tracing_context.get())]))
+
+                    if token is not None:
+                        tracing_context.reset(token)
+
+                    # logging.debug(" ".join(["<..", str(tracing_context.get())]))
+
+                    return result
+
+                except Exception as e:
+                    result = {
+                        "message": str(e),
+                        "stacktrace": traceback.format_exc(),
+                    }
+
+                    self.tracing.set_attributes(
+                        {"traceback_exception": traceback.format_exc()}
+                    )
+
+                    self.tracing.set_status(status="ERROR")
+                    self.tracing.end_span(outputs=result)
+
+                    # logging.debug(" ".join(["<<.", str(tracing_context.get())]))
+
+                    if token is not None:
+                        tracing_context.reset(token)
+
+                    # logging.debug(" ".join(["<..", str(tracing_context.get())]))
+
+                    raise e
+
+            return wrapped_func(*args, **kwargs)
+
+        return async_wrapper if is_coroutine_function else sync_wrapper