diff --git a/.github/workflows/black-formatter.yml b/.github/workflows/black-formatter.yml index ff68c734..8fa24b42 100644 --- a/.github/workflows/black-formatter.yml +++ b/.github/workflows/black-formatter.yml @@ -21,5 +21,6 @@ jobs: python -m pip install --upgrade pip pip install black pip install "black[jupyter]" + - name: Run Black run: black --diff --check . \ No newline at end of file diff --git a/.github/workflows/tach-check.yml b/.github/workflows/tach-check.yml new file mode 100644 index 00000000..2bbbd15e --- /dev/null +++ b/.github/workflows/tach-check.yml @@ -0,0 +1,25 @@ + +name: Tach Check + +on: [pull_request] + +jobs: + tach-check: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v2 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.11' # Specify the version of Python you need + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install tach + + - name: Run Tach + run: tach check \ No newline at end of file diff --git a/agentops/__init__.py b/agentops/__init__.py index d3b3b7f3..5fcefb9c 100755 --- a/agentops/__init__.py +++ b/agentops/__init__.py @@ -3,12 +3,14 @@ import os import logging from typing import Optional, List, Union + from .client import Client -from .config import Configuration +from .config import ClientConfiguration from .event import Event, ActionEvent, LLMEvent, ToolEvent, ErrorEvent from .decorators import record_function from .agent import track_agent from .log_config import logger +from .session import Session try: from .partners.langchain_callback_handler import ( @@ -43,12 +45,11 @@ def init( max_wait_time: Optional[int] = None, max_queue_size: Optional[int] = None, tags: Optional[List[str]] = None, - override: Optional[bool] = None, # Deprecated instrument_llm_calls=True, auto_start_session=True, inherited_session_id: Optional[str] = None, skip_auto_end_session: Optional[bool] = False, -): +) -> Union[Session, None]: """ Initializes the AgentOps singleton pattern. @@ -65,11 +66,10 @@ def init( max_queue_size (int, optional): The maximum size of the event queue. Defaults to 100. tags (List[str], optional): Tags for the sessions that can be used for grouping or sorting later (e.g. ["GPT-4"]). - override (bool, optional): [Deprecated] Use `instrument_llm_calls` instead. Whether to instrument LLM calls and emit LLMEvents.. - instrument_llm_calls (bool): Whether to instrument LLM calls and emit LLMEvents.. + instrument_llm_calls (bool): Whether to instrument LLM calls and emit LLMEvents. auto_start_session (bool): Whether to start a session automatically when the client is created. inherited_session_id (optional, str): Init Agentops with an existing Session - skip_auto_end_session (optional, bool): Don't automatically end session based on your framework's decision making + skip_auto_end_session (optional, bool): Don't automatically end session based on your framework's decision-making (i.e. Crew determining when tasks are complete and ending the session) Attributes: """ logging_level = os.getenv("AGENTOPS_LOGGING_LEVEL") @@ -89,17 +89,24 @@ def init( max_wait_time=max_wait_time, max_queue_size=max_queue_size, tags=tags, - override=override, instrument_llm_calls=instrument_llm_calls, - auto_start_session=auto_start_session, + auto_start_session=False, # handled below inherited_session_id=inherited_session_id, skip_auto_end_session=skip_auto_end_session, ) + # handle auto_start_session here so we can get the session object to return rather than client above + # if the client automatically starts a session from a partner framework don't start a second + session = None + if auto_start_session and len(c.current_session_ids) == 0: + session = c.start_session( + tags=tags, config=c.config, inherited_session_id=inherited_session_id + ) + global is_initialized is_initialized = True - return inherited_session_id or c.current_session_id + return session def end_session( @@ -125,18 +132,25 @@ def end_session( ) +# Mostly used for unit testing - +# prevents unexpected sessions on new tests +def end_all_sessions() -> None: + return Client().end_all_sessions() + + def start_session( tags: Optional[List[str]] = None, - config: Optional[Configuration] = None, + config: Optional[ClientConfiguration] = None, inherited_session_id: Optional[str] = None, -): +) -> Union[Session, None]: """ Start a new session for recording events. Args: tags (List[str], optional): Tags that can be used for grouping or sorting later. e.g. ["test_run"]. - config: (Configuration, optional): Client configuration object + config: (Configuration, optional): Client configuration object, + inherited_session_id: (str, optional): Set the session ID to inherit from another client """ try: @@ -161,7 +175,6 @@ def record(event: Union[Event, ErrorEvent]): Client().record(event) -@check_init def add_tags(tags: List[str]): """ Append to session tags at runtime. @@ -172,7 +185,6 @@ def add_tags(tags: List[str]): Client().add_tags(tags) -@check_init def set_tags(tags: List[str]): """ Replace session tags at runtime. @@ -189,7 +201,7 @@ def get_api_key() -> str: def set_parent_key(parent_key): """ - Set the parent API key which has visibility to projects it is parent to. + Set the parent API key so another organization can view data. Args: parent_key (str): The API key of the parent organization to set. diff --git a/agentops/agent.py b/agentops/agent.py index 1b4c4e64..11b95134 100644 --- a/agentops/agent.py +++ b/agentops/agent.py @@ -18,8 +18,15 @@ def new_init(self, *args, **kwargs): try: original_init(self, *args, **kwargs) self.agent_ops_agent_id = str(uuid4()) + + session = kwargs.get("session", None) + if session is not None: + self.agent_ops_session_id = session.session_id + Client().create_agent( - name=self.agent_ops_agent_name, agent_id=self.agent_ops_agent_id + name=self.agent_ops_agent_name, + agent_id=self.agent_ops_agent_id, + session=session, ) except AttributeError as e: logger.warning( diff --git a/agentops/client.py b/agentops/client.py index 34db1359..5e9bd773 100644 --- a/agentops/client.py +++ b/agentops/client.py @@ -13,30 +13,30 @@ import threading import traceback import logging -from decimal import Decimal +from decimal import Decimal, ROUND_HALF_UP from uuid import UUID, uuid4 from typing import Optional, List, Union from .event import ActionEvent, ErrorEvent, Event from .enums import EndState +from .exceptions import NoSessionException, MultiSessionException, ConfigurationError from .helpers import ( get_ISO_time, - singleton, check_call_stack_for_agent_id, get_partner_frameworks, + conditional_singleton, ) from .session import Session -from .worker import Worker from .host_env import get_host_env from .log_config import logger from .meta_client import MetaClient -from .config import Configuration, ConfigurationError +from .config import ClientConfiguration from .llm_tracker import LlmTracker from termcolor import colored from typing import Tuple -@singleton +@conditional_singleton class Client(metaclass=MetaClient): """ Client for AgentOps service. @@ -62,8 +62,6 @@ class Client(metaclass=MetaClient): skip_auto_end_session (optional, bool): Don't automatically end session based on your framework's decision making Attributes: _session (Session, optional): A Session is a grouping of events (e.g. a run of your agent). - _worker (Worker, optional): A Worker manages the event queue and sends session updates to the AgentOps api - server """ def __init__( @@ -88,8 +86,7 @@ def __init__( ) instrument_llm_calls = instrument_llm_calls or override - self._session: Optional[Session] = None - self._worker: Optional[Worker] = None + self._sessions: Optional[List[Session]] = [] self._tags: Optional[List[str]] = tags self._tags_for_future_session: Optional[List[str]] = None @@ -100,7 +97,7 @@ def __init__( self.config = None try: - self.config = Configuration( + self.config = ClientConfiguration( api_key=api_key, parent_key=parent_key, endpoint=endpoint, @@ -114,6 +111,7 @@ def __init__( UUID(inherited_session_id) except ConfigurationError: + logger.warning("Failed to setup client Configuration") return self._handle_unclean_exits() @@ -156,7 +154,7 @@ def _check_for_partner_frameworks( return instrument_llm_calls, auto_start_session - def add_tags(self, tags: List[str]): + def add_tags(self, tags: List[str]) -> None: """ Append to session tags at runtime. @@ -169,18 +167,7 @@ def add_tags(self, tags: List[str]): if isinstance(tags, str): # if it's a single string tags = [tags] # make it a list - if self._session: - if self._session.tags is not None: - for tag in tags: - if tag not in self._session.tags: - self._session.tags.append(tag) - else: - self._session.tags = tags - - if self._session is not None and self._worker is not None: - self._worker.update_session(self._session) - - else: + if len(self._sessions) == 0: if self._tags_for_future_session: for tag in tags: if tag not in self._tags_for_future_session: @@ -188,51 +175,49 @@ def add_tags(self, tags: List[str]): else: self._tags_for_future_session = tags - def set_tags(self, tags: List[str]): + return + + session = self._safe_get_session() + + session.add_tags(tags=tags) + + self._update_session(session) + + def set_tags(self, tags: List[str]) -> None: """ Replace session tags at runtime. Args: tags (List[str]): The list of tags to set. """ - self._tags_for_future_session = tags - if self._session is not None and self._worker is not None: - self._session.tags = tags - self._worker.update_session(self._session) + try: + session = self._safe_get_session() + session.set_tags(tags=tags) + except NoSessionException: + self._tags_for_future_session = tags - def record(self, event: Union[Event, ErrorEvent]): + def record(self, event: Union[Event, ErrorEvent]) -> None: """ Record an event with the AgentOps service. Args: event (Event): The event to record. """ - if self._session is None or self._session.has_ended or self._worker is None: - logger.warning("Cannot record event - no current session") - return - if isinstance(event, Event): - if not event.end_timestamp or event.init_timestamp == event.end_timestamp: - event.end_timestamp = get_ISO_time() - elif isinstance(event, ErrorEvent): - if event.trigger_event: - if ( - not event.trigger_event.end_timestamp - or event.trigger_event.init_timestamp - == event.trigger_event.end_timestamp - ): - event.trigger_event.end_timestamp = get_ISO_time() - - event.trigger_event_id = event.trigger_event.id - event.trigger_event_type = event.trigger_event.event_type - self._worker.add_event(event.trigger_event.__dict__) - event.trigger_event = None # removes trigger_event from serialization - - self._worker.add_event(event.__dict__) + session = self._safe_get_session() + session.record(event) def _record_event_sync(self, func, event_name, *args, **kwargs): init_time = get_ISO_time() + session: Optional[Session] = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] + if session is None: + if len(Client().current_session_ids) > 1: + raise ValueError( + "If multiple sessions exists, `session` is a required parameter in the function decorated by @record_function" + ) func_args = inspect.signature(func).parameters arg_names = list(func_args.keys()) # Get default values @@ -265,7 +250,11 @@ def _record_event_sync(self, func, event_name, *args, **kwargs): event.screenshot = returns.screenshot event.end_timestamp = get_ISO_time() - self.record(event) + + if session: + session.record(event) + else: + self.record(event) except Exception as e: self.record(ErrorEvent(trigger_event=event, exception=e)) @@ -277,6 +266,14 @@ def _record_event_sync(self, func, event_name, *args, **kwargs): async def _record_event_async(self, func, event_name, *args, **kwargs): init_time = get_ISO_time() + session: Union[Session, None] = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] + if session is None: + if len(Client().current_session_ids) > 1: + raise ValueError( + "If multiple sessions exists, `session` is a required parameter in the function decorated by @record_function" + ) func_args = inspect.signature(func).parameters arg_names = list(func_args.keys()) # Get default values @@ -311,7 +308,11 @@ async def _record_event_async(self, func, event_name, *args, **kwargs): event.screenshot = returns.screenshot event.end_timestamp = get_ISO_time() - self.record(event) + + if session: + session.record(event) + else: + self.record(event) except Exception as e: self.record(ErrorEvent(trigger_event=event, exception=e)) @@ -324,9 +325,9 @@ async def _record_event_async(self, func, event_name, *args, **kwargs): def start_session( self, tags: Optional[List[str]] = None, - config: Optional[Configuration] = None, + config: Optional[ClientConfiguration] = None, inherited_session_id: Optional[str] = None, - ): + ) -> Union[Session, None]: """ Start a new session for recording events. @@ -346,41 +347,34 @@ def start_session( } logger.setLevel(log_levels.get(logging_level or "INFO", "INFO")) - if self._session is not None: - return logger.warning("Cannot start session - session already started") - if not config and not self.config: - return logger.warning("Cannot start session - missing configuration") + return logger.warning( + "Cannot start session - missing configuration - did you call init()?" + ) session_id = ( UUID(inherited_session_id) if inherited_session_id is not None else uuid4() ) - self._session = Session( + session = Session( session_id=session_id, tags=tags or self._tags_for_future_session, host_env=get_host_env(self._env_data_opt_out), + config=config or self.config, ) - self._worker = Worker(config or self.config) - start_session_result = False - if inherited_session_id is not None: - start_session_result = self._worker.reauthorize_jwt(self._session) - else: - start_session_result = self._worker.start_session(self._session) - - if not start_session_result: - self._session = None + if not session: return logger.warning("Cannot start session - server rejected session") logger.info( colored( - f"\x1b[34mSession Replay: https://app.agentops.ai/drilldown?session_id={self._session.session_id}\x1b[0m", + f"\x1b[34mSession Replay: https://app.agentops.ai/drilldown?session_id={session.session_id}\x1b[0m", "blue", ) ) - return self._session.session_id + self._sessions.append(session) + return session def end_session( self, @@ -393,7 +387,7 @@ def end_session( End the current session with the AgentOps service. Args: - end_state (str): The final state of the session. Options: Success, Fail, or Indeterminate. + end_state (str): The final state of the session. Options: Success, Fail, or Indeterminate (default). end_state_reason (str, optional): The reason for ending the session. video (str, optional): The video screen recording of the session is_auto_end (bool, optional): is this an automatic use of end_session and should be skipped with skip_auto_end_session @@ -402,25 +396,26 @@ def end_session( Decimal: The token cost of the session. Returns 0 if the cost is unknown. """ + session = self._safe_get_session() + session.end_state = end_state + session.end_state_reason = end_state_reason + if is_auto_end and self.config.skip_auto_end_session: return - if self._session is None or self._session.has_ended: - return logger.warning("Cannot end session - no current session") - if not any(end_state == state.value for state in EndState): return logger.warning( "Invalid end_state. Please use one of the EndState enums" ) - if self._worker is None or self._worker._session is None: - return logger.warning("Cannot end session - no current worker or session") + session.video = video + + if not session.end_timestamp: + session.end_timestamp = get_ISO_time() - self._session.video = video - self._session.end_session(end_state, end_state_reason) - token_cost = self._worker.end_session(self._session) + token_cost = session.end_session(end_state=end_state) - if token_cost is None or token_cost == "unknown": + if token_cost == "unknown" or token_cost is None: logger.info("Could not determine cost of run.") token_cost_d = Decimal(0) else: @@ -429,33 +424,47 @@ def end_session( "This run's cost ${}".format( "{:.2f}".format(token_cost_d) if token_cost_d == 0 - else "{:.6f}".format(token_cost_d) + else "{:.6f}".format(token_cost_d.quantize(Decimal('0.000001'), rounding=ROUND_HALF_UP)) ) ) logger.info( colored( - f"\x1b[34mSession Replay: https://app.agentops.ai/drilldown?session_id={self._session.session_id}\x1b[0m", + f"\x1b[34mSession Replay: https://app.agentops.ai/drilldown?session_id={session.session_id}\x1b[0m", "blue", ) ) - self._session = None - self._worker = None + self._sessions.remove(session) return token_cost_d - def create_agent(self, name: str, agent_id: Optional[str] = None): + def create_agent( + self, + name: str, + agent_id: Optional[str] = None, + session: Optional[Session] = None, + ): if agent_id is None: agent_id = str(uuid4()) - if self._worker: - self._worker.create_agent(name=name, agent_id=agent_id) - return agent_id + + # if a session is passed in, use multi-session logic + if session: + return session.create_agent(name=name, agent_id=agent_id) + else: + # if no session passed, assume single session + session = self._safe_get_session() + session.create_agent(name=name, agent_id=agent_id) + + return agent_id def _handle_unclean_exits(self): def cleanup(end_state: str = "Fail", end_state_reason: Optional[str] = None): - # Only run cleanup function if session is created - if self._session is not None: - self.end_session(end_state=end_state, end_state_reason=end_state_reason) + for session in self._sessions: + if session.end_state is None: + session.end_session( + end_state=end_state, + end_state_reason=end_state_reason, + ) def signal_handler(signum, frame): """ @@ -486,10 +495,11 @@ def handle_exception(exc_type, exc_value, exc_traceback): traceback.format_exception(exc_type, exc_value, exc_traceback) ) - self.end_session( - end_state="Fail", - end_state_reason=f"{str(exc_value)}: {formatted_traceback}", - ) + for session in self._sessions: + session.end_session( + end_state="Fail", + end_state_reason=f"{str(exc_value)}: {formatted_traceback}", + ) # Then call the default excepthook to exit the program sys.__excepthook__(exc_type, exc_value, exc_traceback) @@ -507,8 +517,8 @@ def handle_exception(exc_type, exc_value, exc_traceback): sys.excepthook = handle_exception @property - def current_session_id(self): - return self._session.session_id if self._session else None + def current_session_ids(self) -> List[str]: + return [str(s.session_id) for s in self._sessions] @property def api_key(self): @@ -521,8 +531,7 @@ def set_parent_key(self, parent_key: str): Args: parent_key (str): The API key of the parent organization to set. """ - if self._worker: - self._worker.config.parent_key = parent_key + self.config.parent_key = parent_key @property def parent_key(self): @@ -531,3 +540,42 @@ def parent_key(self): def stop_instrumenting(self): if self.llm_tracker: self.llm_tracker.stop_instrumenting() + + # replaces the session currently stored with a specific session_id, with a new session + def _update_session(self, session: Session): + self._sessions[ + self._sessions.index( + [ + sess + for sess in self._sessions + if sess.session_id == session.session_id + ][0] + ) + ] = session + + def _safe_get_session(self) -> Session: + for s in self._sessions: + if s.end_state is not None: + self._sessions.remove(s) + + session = None + if len(self._sessions) == 1: + session = self._sessions[0] + + if len(self._sessions) == 0: + raise NoSessionException("No session exists") + + elif len(self._sessions) > 1: + raise MultiSessionException( + "If multiple sessions exist, you must use session.function(). Example: session.add_tags(...) instead " + "of agentops.add_tags(...). More info: " + "https://docs.agentops.ai/v1/concepts/core-concepts#session-management" + ) + + return session + + def end_all_sessions(self): + for s in self._sessions: + s.end_session() + + self._sessions.clear() diff --git a/agentops/config.py b/agentops/config.py index dbe894dc..40e68be1 100644 --- a/agentops/config.py +++ b/agentops/config.py @@ -1,16 +1,17 @@ """ -AgentOps configuration. +AgentOps Client configuration. Classes: - Configuration: Stores the configuration settings for AgentOps clients. + ClientConfiguration: Stores the configuration settings for AgentOps clients. """ from typing import Optional from os import environ -from .log_config import logger +from .exceptions import ConfigurationError -class Configuration: + +class ClientConfiguration: """ Stores the configuration settings for AgentOps clients. @@ -146,11 +147,3 @@ def skip_auto_end_session(self): @parent_key.setter def parent_key(self, value: str): self._parent_key = value - - -class ConfigurationError(Exception): - """Exception raised for errors related to Configuration""" - - def __init__(self, message: str): - super().__init__(message) - logger.warning(message) diff --git a/agentops/decorators.py b/agentops/decorators.py index c2672bd3..b0517f5e 100644 --- a/agentops/decorators.py +++ b/agentops/decorators.py @@ -1,6 +1,9 @@ +import agentops +from .session import Session from .client import Client import inspect import functools +from typing import Optional def record_function(event_name: str): @@ -18,17 +21,19 @@ def decorator(func): if inspect.iscoroutinefunction(func): @functools.wraps(func) - async def async_wrapper(*args, **kwargs): + async def async_wrapper(*args, session: Optional[Session] = None, **kwargs): return await Client()._record_event_async( - func, event_name, *args, **kwargs + func, event_name, *args, session=session, **kwargs ) return async_wrapper else: @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - return Client()._record_event_sync(func, event_name, *args, **kwargs) + def sync_wrapper(*args, session: Optional[Session] = None, **kwargs): + return Client()._record_event_sync( + func, event_name, *args, session=session, **kwargs + ) return sync_wrapper diff --git a/agentops/enums.py b/agentops/enums.py index 5a687862..cce03392 100644 --- a/agentops/enums.py +++ b/agentops/enums.py @@ -10,6 +10,17 @@ class EventType(Enum): class EndState(Enum): + """ + Enum representing the possible end states of a session. + + Attributes: + SUCCESS: Indicates the session ended successfully. + FAIL: Indicates the session failed. + INDETERMINATE (default): Indicates the session ended with an indeterminate state. + This is the default state if not specified, e.g. if you forget to call end_session() + at the end of your program or don't pass it the end_state parameter + """ + SUCCESS = "Success" FAIL = "Fail" - INDETERMINATE = "Indeterminate" + INDETERMINATE = "Indeterminate" # Default diff --git a/agentops/exceptions.py b/agentops/exceptions.py new file mode 100644 index 00000000..6cd3ce78 --- /dev/null +++ b/agentops/exceptions.py @@ -0,0 +1,19 @@ +from .log_config import logger + + +class MultiSessionException(Exception): + def __init__(self, message): + super().__init__(message) + + +class NoSessionException(Exception): + def __init__(self, message): + super().__init__(message) + + +class ConfigurationError(Exception): + """Exception raised for errors related to Configuration""" + + def __init__(self, message: str): + super().__init__(message) + logger.warning(message) diff --git a/agentops/helpers.py b/agentops/helpers.py index 24b623a3..5c3dc437 100644 --- a/agentops/helpers.py +++ b/agentops/helpers.py @@ -18,18 +18,38 @@ "crewai": (False, True), } +ao_instances = {} + def singleton(class_): - instances = {} def getinstance(*args, **kwargs): - if class_ not in instances: - instances[class_] = class_(*args, **kwargs) - return instances[class_] + if class_ not in ao_instances: + ao_instances[class_] = class_(*args, **kwargs) + return ao_instances[class_] + + return getinstance + + +def conditional_singleton(class_): + + def getinstance(*args, **kwargs): + use_singleton = kwargs.pop("use_singleton", True) + if use_singleton: + if class_ not in ao_instances: + ao_instances[class_] = class_(*args, **kwargs) + return ao_instances[class_] + else: + return class_(*args, **kwargs) return getinstance +def clear_singletons(): + global ao_instances + ao_instances = {} + + def get_ISO_time(): """ Get the current UTC time in ISO 8601 format with milliseconds precision, suffixed with 'Z' to denote UTC timezone. diff --git a/agentops/llm_tracker.py b/agentops/llm_tracker.py index a0c37e10..90fbf0cd 100644 --- a/agentops/llm_tracker.py +++ b/agentops/llm_tracker.py @@ -8,6 +8,7 @@ from packaging.version import Version, parse +from .session import Session from .event import ActionEvent, ErrorEvent, LLMEvent from .helpers import check_call_stack_for_agent_id, get_ISO_time from .log_config import logger @@ -38,10 +39,14 @@ def __init__(self, client): self.completion = "" self.llm_event: Optional[LLMEvent] = None - def _handle_response_v0_openai(self, response, kwargs, init_timestamp): + def _handle_response_v0_openai( + self, response, kwargs, init_timestamp, session: Optional[Session] = None + ): """Handle responses for OpenAI versions v1.0.0""" from openai import AsyncStream, Stream from openai.resources import AsyncCompletions from openai.types.chat import ChatCompletionChunk self.llm_event = LLMEvent(init_timestamp=init_timestamp, params=kwargs) + if session is not None: + self.llm_event.session_id = session.session_id def handle_stream_chunk(chunk: ChatCompletionChunk): # NOTE: prompt/completion usage not returned in response when streaming @@ -184,11 +197,12 @@ def handle_stream_chunk(chunk: ChatCompletionChunk): } self.llm_event.end_timestamp = get_ISO_time() - self.client.record(self.llm_event) + self._safe_record(session, self.llm_event) except Exception as e: - self.client.record( - ErrorEvent(trigger_event=self.llm_event, exception=e) + self._safe_record( + session, ErrorEvent(trigger_event=self.llm_event, exception=e) ) + kwargs_str = pprint.pformat(kwargs) chunk = pprint.pformat(chunk) logger.warning( @@ -237,9 +251,12 @@ async def async_generator(): self.llm_event.completion_tokens = response.usage.completion_tokens self.llm_event.model = response.model - self.client.record(self.llm_event) + self._safe_record(session, self.llm_event) except Exception as e: - self.client.record(ErrorEvent(trigger_event=self.llm_event, exception=e)) + self._safe_record( + session, ErrorEvent(trigger_event=self.llm_event, exception=e) + ) + kwargs_str = pprint.pformat(kwargs) response = pprint.pformat(response) logger.warning( @@ -250,7 +267,9 @@ async def async_generator(): return response - def _handle_response_cohere(self, response, kwargs, init_timestamp): + def _handle_response_cohere( + self, response, kwargs, init_timestamp, session: Optional[Session] = None + ): """Handle responses for Cohere versions >v5.4.0""" from cohere.types.non_streamed_chat_response import NonStreamedChatResponse from cohere.types.streamed_chat_response import ( @@ -267,10 +286,12 @@ def _handle_response_cohere(self, response, kwargs, init_timestamp): # from cohere.types.chat import ChatGenerationChunk # NOTE: Cohere only returns one message and its role will be CHATBOT which we are coercing to "assistant" self.llm_event = LLMEvent(init_timestamp=init_timestamp, params=kwargs) + if session is not None: + self.llm_event.session_id = session.session_id self.action_events = {} - def handle_stream_chunk(chunk): + def handle_stream_chunk(chunk, session: Optional[Session] = None): # We take the first chunk and accumulate the deltas from all subsequent chunks to build one full chat completion if isinstance(chunk, StreamedChatResponse_StreamStart): @@ -289,7 +310,7 @@ def handle_stream_chunk(chunk): "content": chunk.response.text, } self.llm_event.end_timestamp = get_ISO_time() - self.client.record(self.llm_event) + self._safe_record(session, self.llm_event) # StreamedChatResponse_SearchResults = ActionEvent search_results = chunk.response.search_results @@ -322,7 +343,7 @@ def handle_stream_chunk(chunk): action_event.end_timestamp = get_ISO_time() for key, action_event in self.action_events.items(): - self.client.record(action_event) + self._safe_record(session, action_event) elif isinstance(chunk, StreamedChatResponse_TextGeneration): self.llm_event.completion += chunk.text @@ -348,9 +369,10 @@ def handle_stream_chunk(chunk): pass except Exception as e: - self.client.record( - ErrorEvent(trigger_event=self.llm_event, exception=e) + self._safe_record( + session, ErrorEvent(trigger_event=self.llm_event, exception=e) ) + kwargs_str = pprint.pformat(kwargs) chunk = pprint.pformat(chunk) logger.warning( @@ -407,9 +429,11 @@ def generator(): self.llm_event.completion_tokens = response.meta.tokens.output_tokens self.llm_event.model = kwargs.get("model", "command-r-plus") - self.client.record(self.llm_event) + self._safe_record(session, self.llm_event) except Exception as e: - self.client.record(ErrorEvent(trigger_event=self.llm_event, exception=e)) + self._safe_record( + session, ErrorEvent(trigger_event=self.llm_event, exception=e) + ) kwargs_str = pprint.pformat(kwargs) response = pprint.pformat(response) logger.warning( @@ -420,7 +444,9 @@ def generator(): return response - def _handle_response_ollama(self, response, kwargs, init_timestamp): + def _handle_response_ollama( + self, response, kwargs, init_timestamp, session: Optional[Session] = None + ) -> None: self.llm_event = LLMEvent(init_timestamp=init_timestamp, params=kwargs) def handle_stream_chunk(chunk: dict): @@ -458,7 +484,7 @@ def generator(): self.llm_event.prompt = kwargs["messages"] self.llm_event.completion = response["message"] - self.client.record(self.llm_event) + self._safe_record(session, self.llm_event) return response def override_openai_v1_completion(self): @@ -470,9 +496,14 @@ def override_openai_v1_completion(self): def patched_function(*args, **kwargs): init_timestamp = get_ISO_time() + session = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] # Call the original function with its original arguments result = original_create(*args, **kwargs) - return self._handle_response_v1_openai(result, kwargs, init_timestamp) + return self._handle_response_v1_openai( + result, kwargs, init_timestamp, session=session + ) # Override the original method with the patched one completions.Completions.create = patched_function @@ -487,8 +518,13 @@ def override_openai_v1_async_completion(self): async def patched_function(*args, **kwargs): # Call the original function with its original arguments init_timestamp = get_ISO_time() + session = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] result = await original_create_async(*args, **kwargs) - return self._handle_response_v1_openai(result, kwargs, init_timestamp) + return self._handle_response_v1_openai( + result, kwargs, init_timestamp, session=session + ) # Override the original method with the patched one completions.AsyncCompletions.create = patched_function @@ -500,9 +536,14 @@ def override_litellm_completion(self): def patched_function(*args, **kwargs): init_timestamp = get_ISO_time() + session = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] result = original_create(*args, **kwargs) # Note: litellm calls all LLM APIs using the OpenAI format - return self._handle_response_v1_openai(result, kwargs, init_timestamp) + return self._handle_response_v1_openai( + result, kwargs, init_timestamp, session=session + ) litellm.completion = patched_function @@ -514,9 +555,14 @@ def override_litellm_async_completion(self): async def patched_function(*args, **kwargs): # Call the original function with its original arguments init_timestamp = get_ISO_time() + session = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] result = await original_create(*args, **kwargs) # Note: litellm calls all LLM APIs using the OpenAI format - return self._handle_response_v1_openai(result, kwargs, init_timestamp) + return self._handle_response_v1_openai( + result, kwargs, init_timestamp, session=session + ) # Override the original method with the patched one litellm.acompletion = patched_function @@ -530,8 +576,13 @@ def override_cohere_chat(self): def patched_function(*args, **kwargs): # Call the original function with its original arguments init_timestamp = get_ISO_time() + session = kwargs.get("session", None) + if "session" in kwargs.keys(): + del kwargs["session"] result = original_chat(*args, **kwargs) - return self._handle_response_cohere(result, kwargs, init_timestamp) + return self._handle_response_cohere( + result, kwargs, init_timestamp, session=session + ) # Override the original method with the patched one cohere.Client.chat = patched_function @@ -559,7 +610,9 @@ def patched_function(*args, **kwargs): # Call the original function with its original arguments init_timestamp = get_ISO_time() result = original_func["ollama.chat"](*args, **kwargs) - return self._handle_response_ollama(result, kwargs, init_timestamp) + return self._handle_response_ollama( + result, kwargs, init_timestamp, session=kwargs.get("session", None) + ) # Override the original method with the patched one ollama.chat = patched_function @@ -717,3 +770,9 @@ def undo_override_ollama(self): ollama.chat = original_func["ollama.chat"] ollama.Client.chat = original_func["ollama.Client.chat"] ollama.AsyncClient.chat = original_func["ollama.AsyncClient.chat"] + + def _safe_record(self, session, event): + if session is not None: + session.record(event) + else: + self.client.record(event) diff --git a/agentops/meta_client.py b/agentops/meta_client.py index 0b4a9c15..6a188369 100644 --- a/agentops/meta_client.py +++ b/agentops/meta_client.py @@ -56,7 +56,9 @@ def wrapper(self, *args, **kwargs): config = getattr(self, "config", None) if config is not None: type(self).send_exception_to_server( - e, self.config._api_key, self._session + e, + self.config._api_key, + self._sessions[0], # TODO: find which session caused exception ) raise e diff --git a/agentops/session.py b/agentops/session.py index fea50e16..2f0a240b 100644 --- a/agentops/session.py +++ b/agentops/session.py @@ -1,6 +1,17 @@ -from .helpers import get_ISO_time -from typing import Optional, List -from uuid import UUID +import copy +import functools +import json +import threading +import time + +from .event import ErrorEvent, Event +from .log_config import logger +from .config import ClientConfiguration +from .helpers import get_ISO_time, filter_unjsonable, safe_serialize +from typing import Optional, List, Union +from uuid import UUID, uuid4 + +from .http_client import HttpClient class Session: @@ -24,6 +35,7 @@ def __init__( session_id: UUID, tags: Optional[List[str]] = None, host_env: Optional[dict] = None, + config: Optional[ClientConfiguration] = None, ): self.end_timestamp = None self.end_state: Optional[str] = None @@ -33,8 +45,19 @@ def __init__( self.video: Optional[str] = None self.end_state_reason: Optional[str] = None self.host_env = host_env + self.config = config + self.jwt = None + self.lock = threading.Lock() + self.queue = [] + + self.stop_flag = threading.Event() + self.thread = threading.Thread(target=self._run) + self.thread.daemon = True + self.thread.start() - def set_session_video(self, video: str) -> None: + self._start_session() + + def set_video(self, video: str) -> None: """ Sets a url to the video recording of the session. @@ -45,25 +68,187 @@ def set_session_video(self, video: str) -> None: def end_session( self, end_state: str = "Indeterminate", end_state_reason: Optional[str] = None - ) -> None: - """ - End the session with a specified state, rating, and reason. - - Args: - end_state (str, optional): The final state of the session. Options: "Success", "Fail", "Indeterminate" - rating (str, optional): The rating for the session. - end_state_reason (str, optional): The reason for ending the session. Provides context for why the session ended. - """ + ) -> str: + self.end_timestamp = get_ISO_time() self.end_state = end_state self.end_state_reason = end_state_reason - self.end_timestamp = get_ISO_time() - @property - def has_ended(self) -> bool: + self.stop_flag.set() + self.thread.join(timeout=1) + self._flush_queue() + + with self.lock: + payload = {"session": self.__dict__} + + res = HttpClient.post( + f"{self.config.endpoint}/v2/update_session", + json.dumps(filter_unjsonable(payload)).encode("utf-8"), + jwt=self.jwt, + ) + logger.debug(res.body) + self.queue = [] + return res.body.get("token_cost", "unknown") + + def add_tags(self, tags: List[str]) -> None: """ - Returns whether the session has been ended + Append to session tags at runtime. - Returns: - bool: Whether the session has been ended + Args: + tags (List[str]): The list of tags to append. """ - return self.end_state is not None + + # if a string and not a list of strings + if not (isinstance(tags, list) and all(isinstance(item, str) for item in tags)): + if isinstance(tags, str): # if it's a single string + tags = [tags] # make it a list + + if self.tags is None: + self.tags = tags + else: + for tag in tags: + if tag not in self.tags: + self.tags.append(tag) + + self._update_session() + + def set_tags(self, tags): + if not (isinstance(tags, list) and all(isinstance(item, str) for item in tags)): + if isinstance(tags, str): # if it's a single string + tags = [tags] # make it a list + + self.tags = tags + self._update_session() + + def record(self, event: Union[Event, ErrorEvent]): + if isinstance(event, Event): + if not event.end_timestamp or event.init_timestamp == event.end_timestamp: + event.end_timestamp = get_ISO_time() + elif isinstance(event, ErrorEvent): + if event.trigger_event: + if ( + not event.trigger_event.end_timestamp + or event.trigger_event.init_timestamp + == event.trigger_event.end_timestamp + ): + event.trigger_event.end_timestamp = get_ISO_time() + + event.trigger_event_id = event.trigger_event.id + event.trigger_event_type = event.trigger_event.event_type + self.record(event) + event.trigger_event = None # removes trigger_event from serialization + + self._add_event(event.__dict__) + + def _add_event(self, event: dict) -> None: + with self.lock: + self.queue.append(event) + + if len(self.queue) >= self.config.max_queue_size: + self._flush_queue() + + def _reauthorize_jwt(self) -> Union[str, None]: + with self.lock: + payload = {"session_id": self.session_id} + serialized_payload = json.dumps(filter_unjsonable(payload)).encode("utf-8") + res = HttpClient.post( + f"{self.config.endpoint}/v2/reauthorize_jwt", + serialized_payload, + self.config.api_key, + ) + + logger.debug(res.body) + + if res.code != 200: + return None + + jwt = res.body.get("jwt", None) + self.jwt = jwt + return jwt + + def _start_session(self): + self.queue = [] + with self.lock: + payload = {"session": self.__dict__} + serialized_payload = json.dumps(filter_unjsonable(payload)).encode("utf-8") + res = HttpClient.post( + f"{self.config.endpoint}/v2/create_session", + serialized_payload, + self.config.api_key, + self.config.parent_key, + ) + + logger.debug(res.body) + + if res.code != 200: + return False + + jwt = res.body.get("jwt", None) + self.jwt = jwt + if jwt is None: + return False + + return True + + def _update_session(self) -> None: + with self.lock: + payload = {"session": self.__dict__} + + res = HttpClient.post( + f"{self.config.endpoint}/v2/update_session", + json.dumps(filter_unjsonable(payload)).encode("utf-8"), + jwt=self.jwt, + ) + + def _flush_queue(self) -> None: + with self.lock: + queue_copy = copy.deepcopy(self.queue) # Copy the current items + self.queue = [] + + if len(queue_copy) > 0: + payload = { + "events": queue_copy, + } + + serialized_payload = safe_serialize(payload).encode("utf-8") + HttpClient.post( + f"{self.config.endpoint}/v2/create_events", + serialized_payload, + jwt=self.jwt, + ) + + logger.debug("\n") + logger.debug( + f"Session request to {self.config.endpoint}/v2/create_events" + ) + logger.debug(serialized_payload) + logger.debug("\n") + + def _run(self) -> None: + while not self.stop_flag.is_set(): + time.sleep(self.config.max_wait_time / 1000) + if self.queue: + self._flush_queue() + + def create_agent(self, name, agent_id): + if agent_id is None: + agent_id = str(uuid4()) + + payload = { + "id": agent_id, + "name": name, + } + + serialized_payload = safe_serialize(payload).encode("utf-8") + HttpClient.post( + f"{self.config.endpoint}/v2/create_agent", serialized_payload, jwt=self.jwt + ) + + return agent_id + + def patch(self, func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + kwargs["session"] = self + return func(*args, **kwargs) + + return wrapper diff --git a/agentops/worker.py b/agentops/worker.py deleted file mode 100644 index 6315e97f..00000000 --- a/agentops/worker.py +++ /dev/null @@ -1,141 +0,0 @@ -import json -from .log_config import logger -import threading -import time -from .http_client import HttpClient -from .config import Configuration -from .session import Session -from .helpers import safe_serialize, filter_unjsonable -from typing import Dict, Optional - - -class Worker: - def __init__(self, config: Configuration) -> None: - self.config = config - self.queue: list[Dict] = [] - self.lock = threading.Lock() - self.stop_flag = threading.Event() - self.thread = threading.Thread(target=self.run) - self.thread.daemon = True - self.thread.start() - self._session: Optional[Session] = None - self.jwt = None - - def add_event(self, event: dict) -> None: - with self.lock: - self.queue.append(event) - if len(self.queue) >= self.config.max_queue_size: - self.flush_queue() - - def flush_queue(self) -> None: - with self.lock: - if len(self.queue) > 0: - events = self.queue - self.queue = [] - - payload = { - "session_id": getattr(self._session, "session_id", None), - "events": events, - } - - serialized_payload = safe_serialize(payload).encode("utf-8") - HttpClient.post( - f"{self.config.endpoint}/v2/create_events", - serialized_payload, - jwt=self.jwt, - ) - - logger.debug("\n") - logger.debug(f"Worker request to {self.config.endpoint}/events") - logger.debug(serialized_payload) - logger.debug("\n") - - def reauthorize_jwt(self, session: Session) -> bool: - self._session = session - with self.lock: - payload = {"session_id": session.session_id} - serialized_payload = json.dumps(filter_unjsonable(payload)).encode("utf-8") - res = HttpClient.post( - f"{self.config.endpoint}/v2/reauthorize_jwt", - serialized_payload, - self.config.api_key, - ) - - logger.debug(res.body) - - if res.code != 200: - return False - - self.jwt = res.body.get("jwt", None) - if self.jwt is None: - return False - - return True - - def start_session(self, session: Session) -> bool: - self._session = session - with self.lock: - payload = {"session": session.__dict__} - serialized_payload = json.dumps(filter_unjsonable(payload)).encode("utf-8") - res = HttpClient.post( - f"{self.config.endpoint}/v2/create_session", - serialized_payload, - self.config.api_key, - self.config.parent_key, - ) - - logger.debug(res.body) - - if res.code != 200: - return False - - self.jwt = res.body.get("jwt", None) - if self.jwt is None: - return False - - return True - - def end_session(self, session: Session) -> str: - self.stop_flag.set() - self.thread.join(timeout=1) - self.flush_queue() - self._session = None - - with self.lock: - payload = {"session": session.__dict__} - - res = HttpClient.post( - f"{self.config.endpoint}/v2/update_session", - json.dumps(filter_unjsonable(payload)).encode("utf-8"), - jwt=self.jwt, - ) - logger.debug(res.body) - return res.body.get("token_cost", "unknown") - - def update_session(self, session: Session) -> None: - with self.lock: - payload = {"session": session.__dict__} - - res = HttpClient.post( - f"{self.config.endpoint}/v2/update_session", - json.dumps(filter_unjsonable(payload)).encode("utf-8"), - jwt=self.jwt, - ) - - def create_agent(self, agent_id, name): - payload = { - "id": agent_id, - "name": name, - "session_id": getattr(self._session, "session_id", None), - } - - serialized_payload = safe_serialize(payload).encode("utf-8") - HttpClient.post( - f"{self.config.endpoint}/v2/create_agent", serialized_payload, jwt=self.jwt - ) - - def run(self) -> None: - while not self.stop_flag.is_set(): - time.sleep(self.config.max_wait_time / 1000) - if self.queue: - self.flush_queue() diff --git a/docs/images/external/autogen/autogen_integration.png b/docs/images/external/autogen/autogen_integration.png new file mode 100644 index 00000000..c911c887 Binary files /dev/null and b/docs/images/external/autogen/autogen_integration.png differ diff --git a/docs/mint.json b/docs/mint.json index b38ea921..7a7b5333 100644 --- a/docs/mint.json +++ b/docs/mint.json @@ -82,7 +82,8 @@ "v1/usage/environment-variables", "v1/usage/tracking-llm-calls", "v1/usage/tracking-agents", - "v1/usage/recording-events" + "v1/usage/recording-events", + "v1/usage/multiple-sessions" ] }, { diff --git a/docs/v1/concepts/core-concepts.mdx b/docs/v1/concepts/core-concepts.mdx index 5272a05c..31df1f47 100644 --- a/docs/v1/concepts/core-concepts.mdx +++ b/docs/v1/concepts/core-concepts.mdx @@ -32,6 +32,45 @@ Optionally, sessions may include: - **Host Environment**: Automatically gathers basic information about the system on which the session ran. - **Video**: If applicable, an optional video recording of the session. +### Session Management +AgentOps can exist in one of two states: + + + - • Only one session exists at a time. All agent usage is synchronous. + - • Use cases: Scripting, development, local machine use (browser extensions, web client, etc) + + + - • REST server + - • Asynchronous agents + + + +By default, AgentOps operates in single-session mode. All of the [base SDK functions](/v1/usage/sdk-reference) work as expected. + +Under the hood, when you only have one session at a time, AgentOps can use functions like `agentops.add_tags(...)` and know that you want to perform the function on the one and only active session. + +As soon as you create a second session, AgentOps enters **Multi-Session Mode**. As long as more than one session is active, the [base SDK functions](/v1/usage/sdk-reference) will no longer work. + +If multiple sessions exist, you are expected to call the function on the relevant session. Ex + +```python single session +import agentops +agentops.start_session() +agentops.end_session(end_state='Success') +``` + +```python multi-session +import agentops +session_1 = agentops.start_session() +session_2 = agentops.start_session() + +session_1.end_session(end_state='Success') +session_2.end_session(end_state='Failure') +``` + + +For more documentation on using multiple concurrent sessions, please see [Multiple Sessions](v1/usage/multiple-sessions) and [FastAPI Example](/v1/examples/fastapi). + ### LLMs, Tools, and Actions (Events) Within AgentOps, **LLMs**, **Tools**, and **Actions** are categorized as **Events**, executed by Agents. Agents primarily initiate LLM calls, potentially leading to API/Tool calls, while Actions encompass any other significant procedures, such as executing functions, taking screenshots, etc. diff --git a/docs/v1/concepts/sessions.mdx b/docs/v1/concepts/sessions.mdx index c0db77d3..25f95f88 100644 --- a/docs/v1/concepts/sessions.mdx +++ b/docs/v1/concepts/sessions.mdx @@ -9,13 +9,11 @@ The AgentOps dashboard provides detailed insights at the session level, includin **There must be an active session in order to use AgentOps.** -Only one session can be active a single time. - --- ## `Session` -#### Properties +### Properties Sessions possess the following attributes: - **ID**: A unique identifier for the session. @@ -30,15 +28,41 @@ Optionally, sessions may include: - **Host Environment**: Automatically gathers basic information about the system on which the session ran. - **Video**: If applicable, an optional video recording of the session. +### Methods +#### `end_session` +**Params** +- **end_state** (str, enum): Success|Failure|Indeterminate +- **end_state_reason** (optional, str): additional notes on end state + +**Returns** (str): Total cost of session in USD + +#### `record` +**Params** +- **event** ([Event](/v1/concepts/events#event-class)): The Event to record as part of the session + + +#### `add_tags` +**Params** +- **tags** (List[str]): a list of tags to assign to append to the current tags + +#### `set_tags` +**Params** +- **tags** (List[str]): a list of tags to assign to append to set + +_Note: Overrides any current tags_ + + ## Starting a Session When you call `agentops.init()`, a session is automatically started. Calling `agentops.init(auto_start_session=False)` will initialize the AgentOps SDK but not start a session. To start a session later, call `agentops.start_session()` [(reference)](/v1/usage/sdk-reference/#start-session) +Both `agentops.init()` and `agentops.start_session()` works as a factory pattern and returns a `Session` object. The above methods can all be called on this session object. + ## Ending a Session If a process ends without any call to agentops, it will show in the dashboard as `Indeterminate`. -To end with a state, call `agentops.end_session()` [(reference)](/v1/usage/sdk-reference/#end-session) +To end with a state, call either `agentops.end_session(...)` [(reference)](/v1/usage/sdk-reference/#end-session) if only one session is in use. Otherwise use `session.end_session(...)` ## Inherited Sessions When working with multiple agents running in different processes, it's possible to initialize AgentOps or start a session @@ -52,11 +76,11 @@ You can retrieve the current session_id by assigning the returned value from `in ```python python import agentops -session_id = agentops.init() -# pass session_id to the other process +session = agentops.init() +# pass session.session_id to the other process # -- other process -- -session_id = retrieve_session_id() +session_id = retrieve_session_id() # <-- your function agentops.init(inherited_session_id=) ``` diff --git a/docs/v1/examples.mdx b/docs/v1/examples.mdx index 6a875590..9560e569 100644 --- a/docs/v1/examples.mdx +++ b/docs/v1/examples.mdx @@ -10,14 +10,20 @@ mode: "wide" Jupyter Notebook with sample code that you can run! Start here! + + CrewAI multi-agent framework with AgentOps support + + + AutoGen multi-agent conversible workflow with tool usage + Jupyter Notebook with a simple multi-agent design Jupyter Notebook with a sample LangChain integration - - CrewAI multi-agent framework with AgentOps support + + Create a REST server that performs and observes agent tasks @@ -45,4 +51,5 @@ mode: "wide" - \ No newline at end of file + + diff --git a/docs/v1/examples/fastapi.mdx b/docs/v1/examples/fastapi.mdx new file mode 100644 index 00000000..5a3a4b14 --- /dev/null +++ b/docs/v1/examples/fastapi.mdx @@ -0,0 +1,110 @@ +--- +title: 'Fast API' +description: 'Observing agents in a server environment' +mode: "wide" +--- + +[//]: # (Card for video tutorial) +[//]: # () + +[//]: # ( Using agents in a REST server and observing) + +[//]: # ( ![thumbnail](https://cdn.loom.com/sessions/thumbnails/cfcaaef8d4a14cc7a974843bda1076bf-1713568618224-with-play.gif)) + +[//]: # () + +## Adding AgentOps to Crew agents + + + + + ```bash pip + pip install agentops + ``` + ```bash poetry + poetry add agentops + ``` + + + [Give us a star](https://github.com/AgentOps-AI/agentops) on GitHub while you're at it (you may be our 2,000th 😊) + + + + + At this time, Crew with AgentOps integration is in pre-release. In the interim, an official fork has been + made available. After official support is released, this fork will be deprecated and developers will + be encouraged to use the core Crew SDK. + + + ```bash pip + pip install git+https://github.com/AgentOps-AI/crewAI.git@main + ``` + ```bash poetry + poetry add git+https://github.com/AgentOps-AI/crewAI.git@main + ``` + + + + 1. Before calling the `Crew()` constructor in your code, call `agentops.init()` + 2. At the end of your Crew run, call `agentops.end_session("Success")` + + ```python python + import agentops + + # Beginning of program (i.e. main.py, __init__.py) + # IMPORTANT: Must be before calling the `Crew()` constructor + agentops.init() + ... + # End of program (e.g. main.py) + agentops.end_session("Success") # Success|Fail|Indeterminate + ``` + + + Instantiating the AgentOps client will automatically instrument Crew, meaning you will be able to see all + of your sessions on the AgentOps Dashboard along with the full LLM chat histories, cost, token counts, etc. + + + For more features see our [Usage](/v1/usage) section. + + + + Retrieve an API Key from your Settings > [Projects & API Keys](https://app.agentops.ai/settings/projects) page. + + + + + API keys are tied to individual projects.

+ A Default Project has been created for you, so just click Copy API Key + + Set this API Key in your [environment variables](/v1/usage/environment-variables) + ```python .env + AGENTOPS_API_KEY= + ``` + + + Execute your program and visit [app.agentops.ai/drilldown](https://app.agentops.ai/drilldown) to observe your Crew! 🕵️ + + After your run, AgentOps prints a clickable url to console linking directly to your session in the Dashboard + +
{/* Intentionally blank div for newline */} + + + + + + +## Special Considerations with Crew +The Crew framework is capable of determining when all tasks have been accomplished and to halt execution. AgentOps will automatically end your active session +when this determination is made. If you don't want your AgentOps session to end at this time, add an optional parameter to your `agentops.init()` call. + +```python +agentops.init(skip_auto_end_session=True) +``` + +## Crew + AgentOps Examples + + + + + + \ No newline at end of file diff --git a/docs/v1/integrations/autogen.mdx b/docs/v1/integrations/autogen.mdx index acbb1c37..4e39cc1f 100644 --- a/docs/v1/integrations/autogen.mdx +++ b/docs/v1/integrations/autogen.mdx @@ -73,4 +73,5 @@ Autogen has comprehensive [documentation](https://microsoft.github.io/autogen/do - \ No newline at end of file + + diff --git a/docs/v1/integrations/cohere.mdx b/docs/v1/integrations/cohere.mdx index 8f3bf3bd..35ae2ca0 100644 --- a/docs/v1/integrations/cohere.mdx +++ b/docs/v1/integrations/cohere.mdx @@ -110,4 +110,5 @@ This is a living integration. Should you need any added functionality message us - \ No newline at end of file + + diff --git a/docs/v1/integrations/crewai.mdx b/docs/v1/integrations/crewai.mdx index 57945bfe..07f7c3ac 100644 --- a/docs/v1/integrations/crewai.mdx +++ b/docs/v1/integrations/crewai.mdx @@ -6,14 +6,14 @@ description: '[CrewAI](https://crewai.io) is a framework for easily building mul import CodeTooltip from '/snippets/add-code-tooltip.mdx' import EnvTooltip from '/snippets/add-env-tooltip.mdx' -AgentOps and CrewAI teamed up to make monitoring Crew agents dead simple. +AgentOps and CrewAI teamed up to make monitoring Crew agents dead simple. Crew and AgentOps have a first class partnership, adding agent observability to all Crew runs with 3 lines of code. CrewAI multi-agent framework with AgentOps support ![thumbnail](https://cdn.loom.com/sessions/thumbnails/cfcaaef8d4a14cc7a974843bda1076bf-1713568618224-with-play.gif) -Crew has comprehensive [documentation](https://docs.crewai.com) available as well as a great [quickstart](https://docs.crewai.com/how-to/Creating-a-Crew-and-kick-it-off/). +Crew has comprehensive [documentation](https://docs.crewai.com) available as well as a great [quickstart](https://docs.crewai.com/how-to/Creating-a-Crew-and-kick-it-off/) guide. ## Adding AgentOps to Crew agents @@ -29,18 +29,13 @@ Crew has comprehensive [documentation](https://docs.crewai.com) available as wel [Give us a star](https://github.com/AgentOps-AI/agentops) on GitHub while you're at it (you may be our 2,000th 😊) - - - At this time, Crew with AgentOps integration is in pre-release. In the interim, an official fork has been - made available. After official support is released, this fork will be deprecated and developers will - be encouraged to use the core Crew SDK. - + ```bash pip - pip install git+https://github.com/AgentOps-AI/crewAI.git@main + pip install 'crewai[agentops]' ``` ```bash poetry - poetry add git+https://github.com/AgentOps-AI/crewAI.git@main + poetry add 'crewai[agentops]' ``` @@ -99,4 +94,5 @@ agentops.init(skip_auto_end_session=True) - \ No newline at end of file + + diff --git a/docs/v1/integrations/langchain.mdx b/docs/v1/integrations/langchain.mdx index 727ae88f..575091f3 100644 --- a/docs/v1/integrations/langchain.mdx +++ b/docs/v1/integrations/langchain.mdx @@ -109,4 +109,5 @@ AgentOps works seamlessly with applications built using Langchain. - \ No newline at end of file + + diff --git a/docs/v1/integrations/litellm.mdx b/docs/v1/integrations/litellm.mdx index 475ed466..8ce75369 100644 --- a/docs/v1/integrations/litellm.mdx +++ b/docs/v1/integrations/litellm.mdx @@ -44,4 +44,5 @@ response = await litellm.acompletion(model="claude-3", messages=messages) - \ No newline at end of file + + diff --git a/docs/v1/introduction.mdx b/docs/v1/introduction.mdx index 2dad129c..f269be0e 100644 --- a/docs/v1/introduction.mdx +++ b/docs/v1/introduction.mdx @@ -62,4 +62,4 @@ AI's biggest problem is that it flies blind... but how can you fix what you can' - \ No newline at end of file + diff --git a/docs/v1/quickstart.mdx b/docs/v1/quickstart.mdx index 62c32b4f..9f8cf575 100644 --- a/docs/v1/quickstart.mdx +++ b/docs/v1/quickstart.mdx @@ -145,4 +145,5 @@ agentops.end_session('Success') - \ No newline at end of file + + diff --git a/docs/v1/scripts/adjust_api_dynamically.js b/docs/v1/scripts/adjust_api_dynamically.js new file mode 100644 index 00000000..e69de29b diff --git a/docs/v1/scripts/stars.js b/docs/v1/scripts/stars.js new file mode 100644 index 00000000..6b8e6b5c --- /dev/null +++ b/docs/v1/scripts/stars.js @@ -0,0 +1,28 @@ +function updateStars() { + fetch("https://api.github.com/repos/AgentOps-AI/agentops") + .then((response) => response.json()) + .then((data) => { + const stars = Math.ceil(data.stargazers_count / 100) * 100 + 100; + setTimeout(() => { + const dataContainer = document.getElementById("stars-text"); + dataContainer.innerHTML = `${stars.toLocaleString()}th`; + }, 50); + }) + .catch((error) => { + // console.error("Github Stars pull error:", error); + }); +} + +function addNewEventListeners() { + setTimeout(() => { + document.querySelectorAll('li, a').forEach(element => { + element.addEventListener('click', updateStars); + }); + }, 50); +} + +window.addEventListener('load', function() { + updateStars(); + const observer = new MutationObserver(addNewEventListeners); + observer.observe(document.body, { childList: true, subtree: true }); +}); \ No newline at end of file diff --git a/docs/v1/usage/environment-variables.mdx b/docs/v1/usage/environment-variables.mdx index 42a47904..7389f9dc 100644 --- a/docs/v1/usage/environment-variables.mdx +++ b/docs/v1/usage/environment-variables.mdx @@ -33,4 +33,5 @@ AGENTOPS_ENV_DATA_OPT_OUT=FALSE - \ No newline at end of file + + diff --git a/docs/v1/usage/langchain-callback-handler.mdx b/docs/v1/usage/langchain-callback-handler.mdx index 98cfde73..9b36644d 100644 --- a/docs/v1/usage/langchain-callback-handler.mdx +++ b/docs/v1/usage/langchain-callback-handler.mdx @@ -70,4 +70,5 @@ If your project uses models with Langchain that are not yet supported by AgentOp - \ No newline at end of file + + diff --git a/docs/v1/usage/multiple-sessions.mdx b/docs/v1/usage/multiple-sessions.mdx new file mode 100644 index 00000000..38c29aac --- /dev/null +++ b/docs/v1/usage/multiple-sessions.mdx @@ -0,0 +1,230 @@ +--- +title: "Multiple Sessions" +description: "Managing multiple concurrent sessions" +--- + +# Single vs Multi-Session Modes + +In most development and scripting use cases, having only one session active at a time is sufficient. The challenge comes when productionizing agents. + +By default, AgentOps operates in single-session mode. All of the [base SDK functions](/v1/usage/sdk-reference) work as expected. + +Under the hood, when you only have one session at a time, AgentOps can use functions like `agentops.add_tags(...)` and know that you want to perform the function on the one and only active session. + +As soon as you create a second session, AgentOps enters **Multi-Session Mode**. As long as more than one session is active, the [base SDK functions](/v1/usage/sdk-reference) will no longer work. + +If multiple sessions exist, you are expected to call the function on the relevant session. Ex: + +```python single session +import agentops +agentops.start_session() +agentops.end_session(end_state='Success') +``` + +```python multi-session script +import agentops +session_1 = agentops.start_session() +session_2 = agentops.start_session() + +session_1.end_session(end_state='Success') +session_2.end_session(end_state='Failure') +``` + +```python multi-session endpoint +@app.get("/completion") +def completion(): + + session = agentops.start_session() + + messages = [{"role": "user", "content": "Hello"}] + response = session.patch(openai.chat.completions.create)( + model="gpt-3.5-turbo", + messages=messages, + temperature=0.5, + ) + + session.record( + ActionEvent( + action_type="Agent says hello", + params=messages, + returns=str(response.choices[0].message.content), + ), + ) + + session.end_session(end_state="Success") + + return {"response": response} +``` + + +Functions on `agentops` will no longer work in multi-session mode + +**When in multi-session mode:** + +```python works ✅ +session.end_session(...) +session.add_tags(...) +session.set_tags(...) +``` + +```python does not work ❌ +agentops.end_session(...) +agentops.add_tags(...) +agentops.set_tags(...) +``` + + +# Entering Multi-Session Mode +Creating more than one session puts the AgentOps Client into multi-session mode. + +### Single Session Examples +All of these examples show using AgentOps in single session mode + +```python +agentops.init() +agentops.end_session(end_state="Success") +``` +```python +agentops.init(auto_start_session=False) +session = agentops.start_session() +session.end_session(end_state="Success") +``` + +### Multi Session Examples + +As soon as you create a second session, the SDK operates in multi-session mode. + +```python +session_1 = agentops.init() +session_2 = agentops.start_session() +``` + +```python +agentops.init(auto_start_session=False) +session_1 = agentops.start_session() +session_2 = agentops.start_session() +``` + +# Managing Multiple Sessions +After creating a session, be sure to have the session reference available anywhere where data related to that session is collected. + +The [Session](/v1/concepts/sessions) object has methods as described in the [docs page](/v1/concepts/sessions). + +### Start Sessions +Start a new session with `init()` or `start_session()` depending on whether or not AgentOps has already been initialized. + +```python +session_1 = agentops.init() +session_2 = agentops.start_session() +``` +or + +```python +agentops.init(auto_start_session=False) +session_1 = agentops.start_session() +session_2 = agentops.start_session() +``` + +### Stop Sessions +To stop a currently active session, call `end_session()` on the session object. + +```python +session = agentops.start_session() +session.end_session() +``` + +If you lose access to the session object before calling `end_session()`, the session will be marked as `Indeterminate`. + +### Functions on Sessions + +All methods are described in the [docs page](/v1/concepts/sessions). + +These methods must be called on the session object: + +```python +session = agentops.start_session() +session.record(Event(...)) +``` + +### Examples + + + Create two sessions and perform functions on each + + + Create a REST server with fast-api and manage sessions + + + +# Assigning LLM Calls +When we have multiple active sessions, it's impossible for AgentOps to know which session a particular LLM call belongs to without a little help. + +To track an LLM Call, use [`session.patch()`](/v1/concepts/sessions#patch) + +```python +import agentops +import openai + +session = agentops.start_session() +messages = [{"role": "user", "content": "Hello"}] +response = session.patch(openai.chat.completions.create)( + model="gpt-3.5-turbo", + messages=messages, + temperature=0.5, +) +``` + +If you're using the create function multiple times, you can create a new function with the same method. + +```python +observed_create = session.patch(openai.chat.completions.create) +obs_response = observed_create( + model="gpt-3.5-turbo", + messages=messages, + temperature=0.5, +) +``` + +[//]: # (Alternatively, you can include the session object as a keyword parameter in the completion call.) + +[//]: # () +[//]: # (```python) + +[//]: # (import agentops) + +[//]: # (import openai) + +[//]: # () +[//]: # (session = agentops.start_session()) + +[//]: # (messages = [{"role": "user", "content": "Hello"}]) + +[//]: # (response = openai.chat.completions.create() + +[//]: # ( model="gpt-3.5-turbo",) + +[//]: # ( messages=messages,) + +[//]: # ( temperature=0.5,) + +[//]: # ( session=session) + +[//]: # ()) + +[//]: # (```) + +[//]: # () +[//]: # (Passing `session` as a keyword parameter is functional, but will likely show an Unexpected Argument warning.) + +If you make an LLM completion call without one of these methods while you currently have more than one active session, a `MultiSessionException` will be raised. + + +# Exceptions + +### `MultiSessionException` +_"If multiple sessions exist, you must use session.function(). Example: session.add_tags(...) instead of agentops.add_tags(...)."_ + +Receiving this exception means that you tried to perform a function on the SDK base, but at runtime had more than one active session. + +### `NoSessionException` +A [session](/v1/concepts/session) action was attempted while no session existed on the client. \ No newline at end of file diff --git a/docs/v1/usage/recording-events.mdx b/docs/v1/usage/recording-events.mdx index b3d42a99..2eb17f49 100644 --- a/docs/v1/usage/recording-events.mdx +++ b/docs/v1/usage/recording-events.mdx @@ -37,4 +37,5 @@ record(ActionEvent("event_type1")) - \ No newline at end of file + + diff --git a/docs/v1/usage/sdk-reference.mdx b/docs/v1/usage/sdk-reference.mdx index d5314ed5..647ba101 100644 --- a/docs/v1/usage/sdk-reference.mdx +++ b/docs/v1/usage/sdk-reference.mdx @@ -156,4 +156,5 @@ when using Langchain as your LLM calling library. - \ No newline at end of file + + diff --git a/docs/v1/usage/tracking-agents.mdx b/docs/v1/usage/tracking-agents.mdx index 95f12ead..04c4ec41 100644 --- a/docs/v1/usage/tracking-agents.mdx +++ b/docs/v1/usage/tracking-agents.mdx @@ -23,7 +23,30 @@ class MyAgent: If omitted, agent name defaults to the name of the class (e.g. MyAgent).

If an event does not originate from a tracked agent, agent name defaults to "Default Agent". + + +## Assigning Agents to a Session +If you are using multiple concurrent sessions, it's important to assign a new agent to a session. + +When the `@track_agent()` decorator is used on an agent class, it adds an additional keyword param `session`. + +```python +@track_agent() +class custom_agent: + def completion(self, ...): + ... + +session = agentops.create_session() +agent = custom_agent(session=session) +agent.completion(...) + +session.end_session() +``` + +In this example, we create a custom agent class. We initialize an agent object and pass in the session to ensure the agent is assigned properly. + + \ No newline at end of file diff --git a/docs/v1/usage/tracking-llm-calls.mdx b/docs/v1/usage/tracking-llm-calls.mdx index 22041003..d51137ac 100644 --- a/docs/v1/usage/tracking-llm-calls.mdx +++ b/docs/v1/usage/tracking-llm-calls.mdx @@ -14,6 +14,7 @@ Try these steps: 1. Make sure you have the latest version of the AgentOps SDK installed. We are constantly updating it to support new LLM libraries and releases. 2. Make sure you are calling `agentops.init()` *after* importing the LLM module but *before* you are calling the LLM method. 3. Make sure the `instrument_llm_calls` parameter of `agentops.init()` is set to `True` (default). +4. Make sure if you have more than one concurrent session, to patch the LLM call as described [here](/v1/usage/multiple-sssions). Still not working? Please let us know! You can find us on [Discord](https://discord.gg/DR2abmETjZ), [GitHub](https://github.com/AgentOps-AI/agentops), @@ -30,4 +31,5 @@ To get started, just follow the quick start guide. - \ No newline at end of file + + diff --git a/examples/assets/fastapi-1.png b/examples/assets/fastapi-1.png new file mode 100644 index 00000000..9ec4d8a3 Binary files /dev/null and b/examples/assets/fastapi-1.png differ diff --git a/examples/autogen/AgentChat.ipynb b/examples/autogen/AgentChat.ipynb new file mode 100644 index 00000000..98f23585 --- /dev/null +++ b/examples/autogen/AgentChat.ipynb @@ -0,0 +1,219 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "bb6538d8-2a5d-4a99-b2c1-7130963e4f7b", + "metadata": {}, + "source": [ + "# Adding AgentOps to an existing Autogen service\n", + "\n", + "\n", + "To get started, you'll need to install the AgentOps package and [set an API key](app.agentops.ai).\n", + "\n", + "AgentOps automatically configures itself when it's initialized meaning your agent run data will be tracked and logged to your AgentOps account right away." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d93f2339-7b99-4cf1-9232-c24faba49c7b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=24c5d9f6-fb82-41e6-a468-2dc74a5318a3\u001b[0m\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AgentOps is now running. You can view your session in the link above\n" + ] + } + ], + "source": [ + "import agentops\n", + "\n", + "from autogen import ConversableAgent, UserProxyAgent\n", + "\n", + "# When initializing AgentOps, you can pass in optional tags to help filter sessions\n", + "agentops.init(api_key=\"...\", tags=[\"simple-autogen-example\"])\n", + "\n", + "print(\"AgentOps is now running. You can view your session in the link above\")" + ] + }, + { + "cell_type": "markdown", + "id": "7858f0f6-9aca-4cdb-a514-9fbf7e353d50", + "metadata": {}, + "source": [ + "AutoGen will now start automatically tracking\n", + "\n", + "* LLM prompts and completions\n", + "* Token usage and costs\n", + "* Agent names and actions\n", + "* Correspondence between agents\n", + "* Tool usage\n", + "* Errors" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2962d990-f7ef-43d8-ba09-d29bd8356d9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33magent\u001b[0m (to user):\n", + "\n", + "How can I help you today?\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide feedback to agent. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: Tell me a joke about AgentOps\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser\u001b[0m (to agent):\n", + "\n", + "Tell me a joke about AgentOps\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33magent\u001b[0m (to user):\n", + "\n", + "Why don't AgentOps teams ever play hide and seek?\n", + "\n", + "Because good luck hiding when they always know where everyone is supposed to be!\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide feedback to agent. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: Another\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser\u001b[0m (to agent):\n", + "\n", + "Another\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33magent\u001b[0m (to user):\n", + "\n", + "Why did the AgentOps team bring a ladder to work?\n", + "\n", + "Because they’re always reaching for high-level optimizations!\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide feedback to agent. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: exit\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: This run's cost $0.001080\n", + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=24c5d9f6-fb82-41e6-a468-2dc74a5318a3\u001b[0m\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Success! Visit your AgentOps dashboard to see the replay\n" + ] + } + ], + "source": [ + "# Define an openai api key for the agent configurations\n", + "openai_api_key = \"...\"\n", + "config_list = [\n", + " {\"model\": \"gpt-4-turbo\", \"api_key\": openai_api_key, \"tags\": [\"gpt-4\", \"tool\"]}\n", + "]\n", + "\n", + "# Create the agent that uses the LLM.\n", + "assistant = ConversableAgent(\"agent\", llm_config={\"config_list\": config_list})\n", + "\n", + "# Create the agent that represents the user in the conversation.\n", + "user_proxy = UserProxyAgent(\"user\", code_execution_config=False)\n", + "\n", + "# Let the assistant start the conversation. It will end when the user types \"exit\".\n", + "assistant.initiate_chat(user_proxy, message=\"How can I help you today?\")\n", + "\n", + "# Close your AgentOps session to indicate that it completed.\n", + "agentops.end_session(\"Success\")\n", + "print(\"Success! Visit your AgentOps dashboard to see the replay\")" + ] + }, + { + "cell_type": "markdown", + "id": "7b422137-903a-41ef-a4ca-95b50aea4138", + "metadata": {}, + "source": [ + "You can view data on this run at [app.agentops.ai](app.agentops.ai).\n", + "\n", + "The dashboard will display LLM events for each message sent by each agent, including those made by the human user." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72993a75-1031-4874-aa26-0ef816a3256c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/autogen/MathAgent.ipynb b/examples/autogen/MathAgent.ipynb new file mode 100644 index 00000000..d7100c30 --- /dev/null +++ b/examples/autogen/MathAgent.ipynb @@ -0,0 +1,322 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "bb6538d8-2a5d-4a99-b2c1-7130963e4f7b", + "metadata": {}, + "source": [ + "# Adding AgentOps to an existing Autogen service\n", + "\n", + "\n", + "To get started, you'll need to install the AgentOps package and [set an API key](app.agentops.ai).\n", + "\n", + "AgentOps automatically configures itself when it's initialized meaning your agent run data will be tracked and logged to your AgentOps account right away." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d93f2339-7b99-4cf1-9232-c24faba49c7b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=51556b00-428b-4cae-b815-1320ebc7e810\u001b[0m\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AgentOps is now running. You can view your session in the link above\n" + ] + } + ], + "source": [ + "from typing import Annotated, Literal\n", + "from autogen import ConversableAgent, register_function\n", + "import agentops\n", + "\n", + "agentops.init(api_key=\"...\", tags=[\"autogen-tool-example\"])\n", + "\n", + "print(\"AgentOps is now running. You can view your session in the link above\")" + ] + }, + { + "cell_type": "markdown", + "id": "7858f0f6-9aca-4cdb-a514-9fbf7e353d50", + "metadata": {}, + "source": [ + "AutoGen will now start automatically tracking\n", + "\n", + "* LLM prompts and completions\n", + "* Token usage and costs\n", + "* Agent names and actions\n", + "* Correspondence between agents\n", + "* Tool usage\n", + "* Errors" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2962d990-f7ef-43d8-ba09-d29bd8356d9f", + "metadata": {}, + "outputs": [], + "source": [ + "# Define an openai api key for the agent configurations\n", + "openai_api_key = \"...\"\n", + "config_list = [\n", + " {\"model\": \"gpt-4-turbo\", \"api_key\": openai_api_key, \"tags\": [\"gpt-4\", \"tool\"]}\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e4dfe37-85e0-4035-a314-3459c6e378c4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: Cannot start session - session already started\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "What is (1423 - 123) / 3 + (32 + 23) * 5?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/reibs/Projects/autogen/autogen/agentchat/conversable_agent.py:2489: UserWarning: Function 'calculator' is being overridden.\n", + " warnings.warn(f\"Function '{tool_sig['function']['name']}' is being overridden.\", UserWarning)\n", + "/Users/reibs/Projects/autogen/autogen/agentchat/conversable_agent.py:2408: UserWarning: Function 'calculator' is being overridden.\n", + " warnings.warn(f\"Function '{name}' is being overridden.\", UserWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_pSJXJKu1qbfRV4SVNHzTaG1z): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\"a\": 1423, \"b\": 123, \"operator\": \"-\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\u001b[32m***** Suggested tool call (call_kHRXi8vq5XsZSrGDnVTA1oy7): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\"a\": 32, \"b\": 23, \"operator\": \"+\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_pSJXJKu1qbfRV4SVNHzTaG1z) *****\u001b[0m\n", + "1300\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_kHRXi8vq5XsZSrGDnVTA1oy7) *****\u001b[0m\n", + "55\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_srDG3bYDpkdoIVn1mVVJNTJj): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\"a\": 1300, \"b\": 3, \"operator\": \"/\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\u001b[32m***** Suggested tool call (call_jXJHjxZlnsHEbLaG4hQXUX1v): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\"a\": 55, \"b\": 5, \"operator\": \"*\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_srDG3bYDpkdoIVn1mVVJNTJj) *****\u001b[0m\n", + "433\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_jXJHjxZlnsHEbLaG4hQXUX1v) *****\u001b[0m\n", + "275\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_jKyiL6oizDZPfX16hhVi6pa3): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\"a\":433,\"b\":275,\"operator\":\"+\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_jKyiL6oizDZPfX16hhVi6pa3) *****\u001b[0m\n", + "708\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "The result of the expression \\((1423 - 123) / 3 + (32 + 23) * 5\\) is 708. \n", + "\n", + "'TERMINATE'\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: This run's cost $0.000600\n", + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=51556b00-428b-4cae-b815-1320ebc7e810\u001b[0m\u001b[0m\n" + ] + } + ], + "source": [ + "Operator = Literal[\"+\", \"-\", \"*\", \"/\"]\n", + "\n", + "\n", + "def calculator(a: int, b: int, operator: Annotated[Operator, \"operator\"]) -> int:\n", + " if operator == \"+\":\n", + " return a + b\n", + " elif operator == \"-\":\n", + " return a - b\n", + " elif operator == \"*\":\n", + " return a * b\n", + " elif operator == \"/\":\n", + " return int(a / b)\n", + " else:\n", + " raise ValueError(\"Invalid operator\")\n", + "\n", + "\n", + "# Create the agent that uses the LLM.\n", + "assistant = ConversableAgent(\n", + " name=\"Assistant\",\n", + " system_message=\"You are a helpful AI assistant. \"\n", + " \"You can help with simple calculations. \"\n", + " \"Return 'TERMINATE' when the task is done.\",\n", + " llm_config={\"config_list\": config_list},\n", + ")\n", + "\n", + "# The user proxy agent is used for interacting with the assistant agent\n", + "# and executes tool calls.\n", + "user_proxy = ConversableAgent(\n", + " name=\"User\",\n", + " llm_config=False,\n", + " is_termination_msg=lambda msg: msg.get(\"content\") is not None\n", + " and \"TERMINATE\" in msg[\"content\"],\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "assistant.register_for_llm(name=\"calculator\", description=\"A simple calculator\")(\n", + " calculator\n", + ")\n", + "user_proxy.register_for_execution(name=\"calculator\")(calculator)\n", + "\n", + "# Register the calculator function to the two agents.\n", + "register_function(\n", + " calculator,\n", + " caller=assistant, # The assistant agent can suggest calls to the calculator.\n", + " executor=user_proxy, # The user proxy agent can execute the calculator calls.\n", + " name=\"calculator\", # By default, the function name is used as the tool name.\n", + " description=\"A simple calculator\", # A description of the tool.\n", + ")\n", + "\n", + "# Let the assistant start the conversation. It will end when the user types \"exit\".\n", + "user_proxy.initiate_chat(assistant, message=\"What is (1423 - 123) / 3 + (32 + 23) * 5?\")\n", + "\n", + "agentops.end_session(\"Success\")" + ] + }, + { + "cell_type": "markdown", + "id": "f67b0305-1247-489e-b1b0-829127af76d3", + "metadata": {}, + "source": [ + "You can see your run in action at [app.agentops.ai](app.agentops.ai). In this example, the AgentOps dashboard will show:\n", + "\n", + "* Agents talking to each other\n", + "* Each use of the calculator tool\n", + "* Each call to OpenAI for LLM use" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b8919ec-ff81-4c94-95de-0d2c5dabbdd9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/langchain_examples.ipynb b/examples/langchain_examples.ipynb index bcde344d..4fcba18a 100644 --- a/examples/langchain_examples.ipynb +++ b/examples/langchain_examples.ipynb @@ -16,12 +16,7 @@ "cell_type": "code", "execution_count": null, "id": "initial_id", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-15T20:21:11.477270Z", - "start_time": "2023-12-15T20:21:10.289895Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import os\n", @@ -40,61 +35,56 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "585f00bb186711a7", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-15T20:21:11.478111Z", - "start_time": "2023-12-15T20:21:11.471462Z" - } - }, "outputs": [], "source": [ - "from agentops.langchain_callback_handler import (\n", + "from agentops.partners.langchain_callback_handler import (\n", " LangchainCallbackHandler as AgentOpsLangchainCallbackHandler,\n", ")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "7e8f8cd098ad5b57", + "execution_count": null }, { "cell_type": "markdown", - "id": "523be945b85dc5d5", - "metadata": {}, "source": [ "Next, we'll grab our two API keys. You can use dotenv like below or however else you like to load environment variables" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "14a1b8e08a2e9eb3" }, { "cell_type": "code", - "execution_count": null, - "id": "1490411415d7317c", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-15T20:21:11.494019Z", - "start_time": "2023-12-15T20:21:11.479154Z" - } - }, "outputs": [], "source": [ "from dotenv import load_dotenv\n", "\n", "load_dotenv()" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "ff6cfc570599871f", + "execution_count": null }, { "cell_type": "markdown", - "id": "8371ec020e634dd0", - "metadata": {}, "source": [ "This is where AgentOps comes into play. Before creating our LLM instance via Langchain, first we'll create an instance of the AO LangchainCallbackHandler. After the handler is initialized, a session will be recorded automatically.\n", "\n", "Pass in your API key, and optionally any tags to describe this session for easier lookup in the AO dashboard." - ] + ], + "metadata": { + "collapsed": false + }, + "id": "51f083697b783fa4" }, { "cell_type": "code", - "execution_count": null, - "id": "deec8da7-5b88-487e-bb07-e1ec79147b72", - "metadata": {}, "outputs": [], "source": [ "AGENTOPS_API_KEY = os.environ.get(\"AGENTOPS_API_KEY\")\n", @@ -107,39 +97,47 @@ "llm = ChatOpenAI(\n", " openai_api_key=OPENAI_API_KEY, callbacks=[agentops_handler], model=\"gpt-3.5-turbo\"\n", ")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "d432fe915edb6365", + "execution_count": null }, { "cell_type": "markdown", - "id": "576e5f97", - "metadata": {}, "source": [ "You can also retrieve the `session_id` of the newly created session." - ] + ], + "metadata": { + "collapsed": false + }, + "id": "38d309f07363b58e" }, { "cell_type": "code", - "execution_count": null, - "id": "5c4ef053", - "metadata": {}, "outputs": [], "source": [ "print(\"Agent Ops session ID: \" + str(agentops_handler.session_id))" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "f7e3a37cde3f9c22", + "execution_count": null }, { "cell_type": "markdown", - "id": "93aa09ec", - "metadata": {}, "source": [ "Agents generally use tools. Let's define a simple tool here. Tool usage is also recorded." - ] + ], + "metadata": { + "collapsed": false + }, + "id": "42f226ace56ef6f5" }, { "cell_type": "code", - "execution_count": null, - "id": "6abf26f9", - "metadata": {}, "outputs": [], "source": [ "@tool\n", @@ -152,45 +150,46 @@ "\n", "\n", "tools = [find_movie]" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "c103a2edbe837abd" }, { "cell_type": "markdown", - "id": "5cb84fec-8ff4-4f80-8512-94fa76a5aa15", - "metadata": {}, "source": [ "For each tool, you need to also add the callback handler" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "4fb7633857b19bf0" }, { "cell_type": "code", - "execution_count": null, - "id": "71d56635-d0db-4362-b140-5072abee249f", - "metadata": {}, "outputs": [], "source": [ "for t in tools:\n", " t.callbacks = [agentops_handler]" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "a0345f08bf1c5ecd" }, { "cell_type": "markdown", - "id": "58bbca0b49302b2b", - "metadata": {}, "source": [ "Finally, let's use our agent! Pass in the callback handler to the agent, and all the actions will be recorded in the AO Dashboard" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "12a02b833716676b" }, { "cell_type": "code", - "execution_count": null, - "id": "d538b20aa954ee80", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-15T20:21:12.352862Z", - "start_time": "2023-12-15T20:21:12.351126Z" - } - }, "outputs": [], "source": [ "agent = initialize_agent(\n", @@ -203,75 +202,76 @@ " ], # You must pass in a callback handler to record your agent\n", " handle_parsing_errors=True,\n", ")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "2d2e83fa69b30add" }, { "cell_type": "code", - "execution_count": null, - "id": "6dfb127553751384", - "metadata": { - "scrolled": true - }, "outputs": [], "source": [ "agent.run(\"What comedies are playing?\", callbacks=[agentops_handler])" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "df2bc3a384493e1e" }, { - "attachments": { - "3d9393fa-3d6a-4193-b6c9-43413dc19d15.png": { - "image/png": "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" - } - }, "cell_type": "markdown", - "id": "d40d1fa2-5f46-4630-970b-ee7c1ffae276", - "metadata": {}, "source": [ "## Check your session\n", "Finally, check your run on [AgentOps](https://app.agentops.ai)\n", "![image.png](attachment:3d9393fa-3d6a-4193-b6c9-43413dc19d15.png)" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "2230edd919182a55" }, { "cell_type": "markdown", - "id": "1fb5c325-39d7-4703-9ce0-ac00ffd7ffde", - "metadata": {}, "source": [ "# Async Agents\n", "\n", "Several langchain agents require async callback handlers. AgentOps also supports this." - ] + ], + "metadata": { + "collapsed": false + }, + "id": "fbf4a3ec5fa60d74" }, { "cell_type": "code", - "execution_count": null, - "id": "973f00a2-24da-48b3-adf7-97872d0d5afd", - "metadata": {}, "outputs": [], "source": [ "import os\n", "from langchain.chat_models import ChatOpenAI\n", "from langchain.agents import initialize_agent, AgentType\n", "from langchain.agents import tool" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "ed63a166b343e1a2" }, { "cell_type": "code", - "execution_count": null, - "id": "16d8136c-cac2-47a5-85d8-cc466089feea", - "metadata": {}, "outputs": [], "source": [ - "from agentops.langchain_callback_handler import (\n", + "from agentops.partners.langchain_callback_handler import (\n", " AsyncLangchainCallbackHandler as AgentOpsAsyncLangchainCallbackHandler,\n", ")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "aa15223969f97b3d" }, { "cell_type": "code", - "execution_count": null, - "id": "b5986ed0-02d0-4e5f-99cd-c1fdfd7e5f1c", - "metadata": {}, "outputs": [], "source": [ "from dotenv import load_dotenv\n", @@ -280,13 +280,14 @@ "\n", "AGENTOPS_API_KEY = os.environ.get(\"AGENTOPS_API_KEY\")\n", "OPENAI_API_KEY = os.environ.get(\"OPENAI_API_KEY\")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "818357483f039b60" }, { "cell_type": "code", - "execution_count": null, - "id": "bdce6ac1-bdbc-46ba-a9f1-7fd384187016", - "metadata": {}, "outputs": [], "source": [ "agentops_handler = AgentOpsAsyncLangchainCallbackHandler(\n", @@ -298,13 +299,14 @@ ")\n", "\n", "print(\"Agent Ops session ID: \" + str(await agentops_handler.session_id))" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "ae76cfe058f5e4e4" }, { "cell_type": "code", - "execution_count": null, - "id": "d728c326-9a41-498b-bb64-9720577aac3e", - "metadata": {}, "outputs": [], "source": [ "@tool\n", @@ -320,13 +322,14 @@ "\n", "for t in tools:\n", " t.callbacks = [agentops_handler]" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "1201049766be84a7" }, { "cell_type": "code", - "execution_count": null, - "id": "30eddc8b-0c90-4d96-9f1f-45da38c0d984", - "metadata": {}, "outputs": [], "source": [ "agent = initialize_agent(\n", @@ -339,23 +342,24 @@ ")\n", "\n", "await agent.arun(\"What comedies are playing?\")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "8d4f9dd39b79d542" }, { - "attachments": { - "69f2121a-d437-4c09-bbbe-c76c9243ee19.png": { - "image/png": "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" - } - }, "cell_type": "markdown", - "id": "fb276a2e-f1c3-4f0f-8818-b7730e9d3ff7", - "metadata": {}, "source": [ "## Check your session\n", "Finally, check your run on [AgentOps](https://app.agentops.ai)\n", "\n", "![image.png](attachment:69f2121a-d437-4c09-bbbe-c76c9243ee19.png)" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "fb276a2e-f1c3-4f0f-8818-b7730e9d3ff7" } ], "metadata": { @@ -374,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/examples/multi_agent_example.ipynb b/examples/multi_agent_example.ipynb index c429f185..7749cafb 100644 --- a/examples/multi_agent_example.ipynb +++ b/examples/multi_agent_example.ipynb @@ -49,16 +49,16 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "af062552554d60ce", - "metadata": { - "collapsed": false - }, "outputs": [], "source": [ - "agentops.init(AGENTOPS_API_KEY)\n", + "agentops.init(AGENTOPS_API_KEY, tags=[\"multi-agent-notebook\"])\n", "openai_client = OpenAI(api_key=OPENAI_API_KEY)" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "af062552554d60ce", + "execution_count": null }, { "cell_type": "markdown", @@ -138,20 +138,6 @@ "Lets use these agents!" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "69e76061a626549", - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "generated_func = engineer.completion(\n", - " \"Write a python function that accepts two numbers and multiplies them together, then divides by two. No example.\"\n", - ")" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/examples/multi_session_llm.ipynb b/examples/multi_session_llm.ipynb new file mode 100644 index 00000000..6013be80 --- /dev/null +++ b/examples/multi_session_llm.ipynb @@ -0,0 +1,271 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Multiple Concurrent Sessions\n", + "This example will show you how to run multiple sessions concurrently, assigning LLM cals to a specific session." + ], + "metadata": { + "collapsed": false + }, + "id": "a0fe80a38dec2f7b" + }, + { + "cell_type": "code", + "execution_count": null, + "id": "initial_id", + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import agentops\n", + "from openai import OpenAI\n", + "from dotenv import load_dotenv\n", + "from agentops import ActionEvent\n", + "\n", + "load_dotenv()" + ] + }, + { + "cell_type": "markdown", + "source": [ + "First, of course, lets init AgentOps. We're going to bypass creating a session automatically for the sake of showing it below." + ], + "metadata": { + "collapsed": false + }, + "id": "da9cf64965c86ee9" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "agentops.init(auto_start_session=False)\n", + "openai = OpenAI()" + ], + "metadata": { + "collapsed": false + }, + "id": "39af2cd027ce268", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "Now lets create two sessions, each with an identifiable tag." + ], + "metadata": { + "collapsed": false + }, + "id": "9501d298aec35510" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "session_1 = agentops.start_session(tags=[\"multi-session-test-1\"])\n", + "session_2 = agentops.start_session(tags=[\"multi-session-test-2\"])\n", + "\n", + "print(\"session_id_1: {}\".format(session_1.session_id))\n", + "print(\"session_id_2: {}\".format(session_2.session_id))" + ], + "metadata": { + "collapsed": false + }, + "id": "4f24d06dd29579ff", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "## LLM Calls\n", + "Now lets go ahead and make our first OpenAI LLM call. The challenge with having multiple sessions at the same time is that there is no way for AgentOps to know what LLM call is intended to pertain to what active session. This means we need to do a little extra work in one of two ways." + ], + "metadata": { + "collapsed": false + }, + "id": "38f373b7a8878a68" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "messages = [{\"role\": \"user\", \"content\": \"Hello\"}]" + ], + "metadata": { + "collapsed": false + }, + "id": "8a2d65f5fcdb137", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "### Patching Function\n", + "This method involves wrapping the LLM call withing a function on session. It can look a little counter-intuitive, but it easily tells us what session the call belongs to." + ], + "metadata": { + "collapsed": false + }, + "id": "e1859e37b65669b2" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "# option 1: use session.patch\n", + "response = session_1.patch(openai.chat.completions.create)(\n", + " model=\"gpt-3.5-turbo\",\n", + " messages=messages,\n", + " temperature=0.5,\n", + ")" + ], + "metadata": { + "collapsed": false + }, + "id": "106a1c899602bd33", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "### Create patched function\n", + "If you're using the create function multiple times, you can create a new function with the same method" + ], + "metadata": { + "collapsed": false + }, + "id": "3e129661929e8368" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "observed_create = session_1.patch(openai.chat.completions.create)\n", + "obs_response = observed_create(\n", + " model=\"gpt-3.5-turbo\",\n", + " messages=messages,\n", + " temperature=0.5,\n", + ")" + ], + "metadata": { + "collapsed": false + }, + "id": "be3b866ee04ef767", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "### Keyword Argument\n", + "Alternatively, you can also pass the session into the LLM function call as a keyword argument. While this method works and is a bit more readable, it is not a \"pythonic\" pattern and can lead to linting errors in the code, as the base function is not expecting a `session` keyword." + ], + "metadata": { + "collapsed": false + }, + "id": "ec03dbfb7a185d1d" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "# option 2: add session as a keyword argument\n", + "response2 = openai.chat.completions.create(\n", + " model=\"gpt-3.5-turbo\", messages=messages, temperature=0.5, session=session_2\n", + ")" + ], + "metadata": { + "collapsed": false + }, + "id": "4ad4c7629509b4be" + }, + { + "cell_type": "markdown", + "source": [ + "## Recording Events\n", + "Outside of LLM calls, there are plenty of other events that we want to track. You can learn more about these events [here](https://docs.agentops.ai/v1/concepts/events).\n", + "\n", + "Recording these events on a session is as simple as `session.record(...)`" + ], + "metadata": { + "collapsed": false + }, + "id": "e6de84850aa2e135" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "session_1.record(ActionEvent(action_type=\"test event\"))" + ], + "metadata": { + "collapsed": false + }, + "id": "964e3073bac33223" + }, + { + "cell_type": "markdown", + "source": [ + "Now let's go ahead and end the sessions" + ], + "metadata": { + "collapsed": false + }, + "id": "43ac0b9b99eab5c7" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "session_1.end_session(end_state=\"Success\")\n", + "session_2.end_session(end_state=\"Success\")" + ], + "metadata": { + "collapsed": false + }, + "id": "7e3050abcb72421b", + "execution_count": null + }, + { + "cell_type": "markdown", + "source": [ + "If you look in the AgentOps dashboard for these sessions, you will see two unique sessions, both with one LLM Event each, one with an Action Event as well." + ], + "metadata": { + "collapsed": false + }, + "id": "53ea2b8dfee6270a" + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "collapsed": false + }, + "id": "dbc7483434f8c147" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/multion/retrieve.ipynb b/examples/multion/retrieve.ipynb new file mode 100644 index 00000000..e69de29b diff --git a/examples/openai-gpt.ipynb b/examples/openai-gpt.ipynb index 0fe4f241..7898b5fe 100644 --- a/examples/openai-gpt.ipynb +++ b/examples/openai-gpt.ipynb @@ -62,134 +62,104 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "fe8116d5969f1d23", - "metadata": { - "collapsed": false - }, "outputs": [], "source": [ "openai = OpenAI(api_key=OPENAI_API_KEY)\n", - "agentops.init(AGENTOPS_API_KEY)" - ] + "agentops.init(AGENTOPS_API_KEY, tags=[\"openai-gpt-notebook\"])" + ], + "metadata": { + "collapsed": false + }, + "id": "5d424a02e30ce7f4" }, { "cell_type": "markdown", - "id": "3c20bbfa91b3419c", + "source": [ + "Now just use OpenAI as you would normally!" + ], "metadata": { "collapsed": false }, - "source": [ - "Now just use OpenAI as you would normally!" - ] + "id": "c77f4f920c07e3e6" }, { "cell_type": "markdown", - "id": "b42f5685ac4af5c2", + "source": [ + "## Single Session with ChatCompletion" + ], "metadata": { "collapsed": false }, - "source": [ - "## Single Session with ChatCompletion" - ] + "id": "ca7011cf1ba076c9" }, { "cell_type": "code", - "execution_count": null, - "id": "9cd47d3fa1e252e1", - "metadata": { - "collapsed": false - }, "outputs": [], "source": [ "message = ({\"role\": \"user\", \"content\": \"Write a 12 word poem about secret agents.\"},)\n", "res = openai.chat.completions.create(\n", " model=\"gpt-3.5-turbo\", messages=message, temperature=0.5, stream=True\n", ")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "2704d6d625efa77f" }, { "cell_type": "markdown", - "id": "4a231440", - "metadata": {}, "source": [ - "Streamed completions are also automatically logged to AgentOps." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "19704228", - "metadata": {}, - "outputs": [], - "source": [ - "full_response = \"\"\n", - "for chunk in res:\n", - " if chunk.choices[0].delta.content is not None:\n", - " full_response += chunk.choices[0].delta.content\n", - "\n", - "print(full_response.strip())" - ] - }, - { - "cell_type": "markdown", - "id": "bf75276ad9fbb3f4", + "Make sure to end your session with a `Result` (Success|Fail|Indeterminate) for better tracking" + ], "metadata": { "collapsed": false }, - "source": [ - "Make sure to end your session with a `Result` (Success|Fail|Indeterminate) for better tracking" - ] + "id": "ce4965fc1614b5fe" }, { "cell_type": "code", - "execution_count": null, - "id": "f59fe80a7e00e6e8", - "metadata": { - "collapsed": false - }, "outputs": [], "source": [ "agentops.end_session(\"Success\")" - ] - }, - { - "cell_type": "markdown", - "id": "318a7186c1be2d59", + ], "metadata": { "collapsed": false }, - "source": [ - "Now if you check the AgentOps dashboard, you should see information related to this run!" - ] + "id": "537abd77cd0e0d25" }, { "cell_type": "markdown", - "id": "ccf998561cb9a834", + "source": [ + "Now if you check the AgentOps dashboard, you should see information related to this run!" + ], "metadata": { "collapsed": false }, + "id": "dd69580627842705" + }, + { + "cell_type": "markdown", "source": [ "# Events\n", "Additionally, you can track custom events via AgentOps.\n", "Let's start a new session and record some events " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f5a1a63ff4ecf127", + ], "metadata": { "collapsed": false }, + "id": "b824bb935c7b7f80" + }, + { + "cell_type": "code", "outputs": [], "source": [ "# Create new session\n", - "agentops.start_session()\n", - "\n", - "# Optionally, we can add tags to the session\n", - "# ao_client.start_session(['Hello Tracker'])" - ] + "agentops.start_session(tags=[\"openai-gpt-notebook-events\"])" + ], + "metadata": { + "collapsed": false + }, + "id": "544c8f1bdb8c6e4b" }, { "cell_type": "markdown", @@ -253,15 +223,15 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "4ca2b49fc06adddb", - "metadata": { - "collapsed": false - }, "outputs": [], "source": [ "agentops.end_session(\"Success\")" - ] + ], + "metadata": { + "collapsed": false + }, + "id": "4ca2b49fc06adddb", + "execution_count": null } ], "metadata": { diff --git a/examples/recording-events.ipynb b/examples/recording-events.ipynb index 26b2b756..018b6344 100644 --- a/examples/recording-events.ipynb +++ b/examples/recording-events.ipynb @@ -18,8 +18,7 @@ "execution_count": null, "id": "168ecd05cc123de0", "metadata": { - "collapsed": false, - "is_executing": true + "collapsed": false }, "outputs": [], "source": [ diff --git a/pyproject.toml b/pyproject.toml index e7dd6127..d8ef4275 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "agentops" -version = "0.2.6" +version = "0.3.0" authors = [ { name="Alex Reibman", email="areibman@gmail.com" }, { name="Shawn Qiu", email="siyangqiu@gmail.com" }, @@ -23,12 +23,13 @@ dependencies = [ "requests==2.31.0", "psutil==5.9.8", "packaging==23.2", - "termcolor==2.4.0" + "termcolor==2.4.0", ] [project.optional-dependencies] dev = [ "pytest==7.4.0", - "requests_mock==1.11.0" + "requests_mock==1.11.0", + "tach==0.6.9", ] langchain = [ "langchain~=1.19" diff --git a/tach.yml b/tach.yml new file mode 100644 index 00000000..bd03b83d --- /dev/null +++ b/tach.yml @@ -0,0 +1,95 @@ +# yaml-language-server: $schema=https://raw.githubusercontent.com/gauge-sh/tach/v0.6.9/public/tach-yml-schema.json +modules: + - path: agentops + depends_on: + - agentops.agent + - agentops.client + - agentops.config + - agentops.decorators + - agentops.event + - agentops.log_config + - agentops.partners + - agentops.session + - path: agentops.agent + depends_on: + - agentops + - agentops.log_config + - path: agentops.client + depends_on: + - agentops.config + - agentops.enums + - agentops.event + - agentops.exceptions + - agentops.helpers + - agentops.host_env + - agentops.llm_tracker + - agentops.log_config + - agentops.meta_client + - agentops.partners + - agentops.session + - path: agentops.config + depends_on: + - agentops.exceptions + - path: agentops.decorators + depends_on: + - agentops + - agentops.client + - agentops.session + - path: agentops.enums + depends_on: [] + - path: agentops.event + depends_on: + - agentops.enums + - agentops.helpers + - path: agentops.exceptions + depends_on: + - agentops.log_config + - path: agentops.helpers + depends_on: + - agentops.log_config + - path: agentops.host_env + depends_on: + - agentops.helpers + - agentops.log_config + - path: agentops.http_client + depends_on: + - agentops.log_config + - path: agentops.langchain_callback_handler + depends_on: + - agentops + - agentops.helpers + - path: agentops.llm_tracker + depends_on: + - agentops.event + - agentops.helpers + - agentops.log_config + - agentops.session + - path: agentops.log_config + depends_on: [] + - path: agentops.meta_client + depends_on: + - agentops.helpers + - agentops.host_env + - agentops.http_client + - agentops.log_config + - path: agentops.partners + depends_on: + - agentops + - agentops.enums + - agentops.helpers + - agentops.log_config + - path: agentops.session + depends_on: + - agentops.config + - agentops.event + - agentops.helpers + - agentops.http_client + - agentops.log_config +exclude: + - .*__pycache__ + - .*egg-info + - docs + - examples + - tests + - venv +source_root: . diff --git a/tests/core_manual_tests/agentchat_agentops.ipynb b/tests/core_manual_tests/agentchat_agentops.ipynb new file mode 100644 index 00000000..43283d13 --- /dev/null +++ b/tests/core_manual_tests/agentchat_agentops.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "abb8a01d85d8b146", + "metadata": { + "collapsed": false + }, + "source": [ + "# Agent Tracking with AgentOps" + ] + }, + { + "cell_type": "markdown", + "id": "a447802c88c8a240", + "metadata": {}, + "source": [ + "\n", + "\n", + "[AgentOps](https://agentops.ai/?=autogen) provides session replays, metrics, and monitoring for AI agents.\n", + "\n", + "At a high level, AgentOps gives you the ability to monitor LLM calls, costs, latency, agent failures, multi-agent interactions, tool usage, session-wide statistics, and more. For more info, check out the [AgentOps Repo](https://github.com/AgentOps-AI/agentops).\n" + ] + }, + { + "cell_type": "markdown", + "id": "b354c068", + "metadata": {}, + "source": [ + "### Overview Dashboard\n", + "\n", + "\n", + "### Session Replays\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "38182a5296dceb34", + "metadata": {}, + "source": [ + "## Adding AgentOps to an existing Autogen service.\n", + "To get started, you'll need to install the AgentOps package and set an API key.\n", + "\n", + "AgentOps automatically configures itself when it's initialized meaning your agent run data will be tracked and logged to your AgentOps account right away." + ] + }, + { + "cell_type": "markdown", + "id": "8d9451f4", + "metadata": {}, + "source": [ + "````{=mdx}\n", + ":::info Requirements\n", + "Some extra dependencies are needed for this notebook, which can be installed via pip:\n", + "\n", + "```bash\n", + "pip install pyautogen agentops\n", + "```\n", + "\n", + "For more information, please refer to the [installation guide](/docs/installation/).\n", + ":::\n", + "````" + ] + }, + { + "cell_type": "markdown", + "id": "6be9e11620b0e8d6", + "metadata": {}, + "source": [ + "### Set an API key\n", + "\n", + "By default, the AgentOps `init()` function will look for an environment variable named `AGENTOPS_API_KEY`. Alternatively, you can pass one in as an optional parameter.\n", + "\n", + "Create an account and obtain an API key at [AgentOps.ai](https://agentops.ai/settings/projects)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f31a28d20a13b377", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-24T16:33:30.559216Z", + "start_time": "2024-06-24T16:33:29.835666Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=8771cfe1-d607-4987-8398-161cb5dbb5cf\u001b[0m\u001b[0m\n" + ] + }, + { + "data": { + "text/plain": "UUID('8771cfe1-d607-4987-8398-161cb5dbb5cf')" + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import agentops\n", + "\n", + "from autogen import ConversableAgent, UserProxyAgent, config_list_from_json\n", + "\n", + "agentops.init(api_key=\"6f7b89eb-286f-44ed-af9c-a166358e5561\")" + ] + }, + { + "cell_type": "markdown", + "id": "4dd8f461ccd9cbef", + "metadata": {}, + "source": [ + "Autogen will now start automatically tracking\n", + "- LLM prompts and completions\n", + "- Token usage and costs\n", + "- Agent names and actions\n", + "- Correspondence between agents\n", + "- Tool usage\n", + "- Errors" + ] + }, + { + "cell_type": "markdown", + "id": "712315c520536eb8", + "metadata": {}, + "source": [ + "# Simple Chat Example" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "66d68e66e9f4a677", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-24T16:33:37.869859Z", + "start_time": "2024-06-24T16:33:33.308013Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: Cannot start session - session already started\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33magent\u001b[0m (to user):\n", + "\n", + "How can I help you today?\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: This run's cost $0.00\n", + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=8771cfe1-d607-4987-8398-161cb5dbb5cf\u001b[0m\u001b[0m\n" + ] + } + ], + "source": [ + "import agentops\n", + "\n", + "# When initializing AgentOps, you can pass in optional tags to help filter sessions\n", + "agentops.init(\n", + " tags=[\"simple-autogen-example\"], api_key=\"6f7b89eb-286f-44ed-af9c-a166358e5561\"\n", + ")\n", + "\n", + "agentops.start_session()\n", + "\n", + "# Create the agent that uses the LLM.\n", + "config_list = config_list_from_json(env_or_file=\"OAI_CONFIG_LIST\")\n", + "assistant = ConversableAgent(\"agent\", llm_config={\"config_list\": config_list})\n", + "\n", + "# Create the agent that represents the user in the conversation.\n", + "user_proxy = UserProxyAgent(\"user\", code_execution_config=False)\n", + "\n", + "# Let the assistant start the conversation. It will end when the user types \"exit\".\n", + "assistant.initiate_chat(user_proxy, message=\"How can I help you today?\")\n", + "\n", + "# Close your AgentOps session to indicate that it completed.\n", + "agentops.end_session(\"Success\")" + ] + }, + { + "cell_type": "markdown", + "id": "2217ed0f930cfcaa", + "metadata": {}, + "source": [ + "You can view data on this run at [app.agentops.ai](https://app.agentops.ai). \n", + "\n", + "The dashboard will display LLM events for each message sent by each agent, including those made by the human user." + ] + }, + { + "cell_type": "markdown", + "id": "cbd689b0f5617013", + "metadata": { + "collapsed": false + }, + "source": [ + "![session replay](https://github.com/AgentOps-AI/agentops/blob/main/docs/images/external/app_screenshots/session-overview.png?raw=true)" + ] + }, + { + "cell_type": "markdown", + "id": "fd78f1a816276cb7", + "metadata": {}, + "source": [ + "# Tool Example\n", + "AgentOps also tracks when Autogen agents use tools. You can find more information on this example in [tool-use.ipynb](https://github.com/microsoft/autogen/blob/main/website/docs/tutorial/tool-use.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3498aa6176c799ff", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-24T16:36:06.748495Z", + "start_time": "2024-06-24T16:35:51.335319Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=8d257354-f00f-49d2-a35b-b92989efe090\u001b[0m\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "What is (1423 - 123) / 3 + (32 + 23) * 5?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_xbytETVlWVBiXS6sCWyf5x7X): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"a\": 1423,\n", + " \"b\": 123,\n", + " \"operator\": \"-\"\n", + "}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_xbytETVlWVBiXS6sCWyf5x7X) *****\u001b[0m\n", + "1300\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_WkvWoqeKal4qMUI5jujX0vip): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"a\": 1300,\n", + " \"b\": 3,\n", + " \"operator\": \"/\"\n", + "}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_WkvWoqeKal4qMUI5jujX0vip) *****\u001b[0m\n", + "433\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_akFL1K8ClJFH8jRI7k37pcmI): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"a\": 32,\n", + " \"b\": 23,\n", + " \"operator\": \"+\"\n", + "}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_akFL1K8ClJFH8jRI7k37pcmI) *****\u001b[0m\n", + "55\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_4FWgPTqSGLCSsGRl64IimjgS): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"a\": 55,\n", + " \"b\": 5,\n", + " \"operator\": \"*\"\n", + "}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_4FWgPTqSGLCSsGRl64IimjgS) *****\u001b[0m\n", + "275\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_QnMap9mx57bTvNnulfy5kdDO): calculator *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"a\": 433,\n", + " \"b\": 275,\n", + " \"operator\": \"+\"\n", + "}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION calculator...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[33mUser\u001b[0m (to Assistant):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_QnMap9mx57bTvNnulfy5kdDO) *****\u001b[0m\n", + "708\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mAssistant\u001b[0m (to User):\n", + "\n", + "The result of the calculation is 708. \n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "🖇 AgentOps: This run's cost $0.001800\n", + "🖇 AgentOps: \u001b[34m\u001b[34mSession Replay: https://app.agentops.ai/drilldown?session_id=8d257354-f00f-49d2-a35b-b92989efe090\u001b[0m\u001b[0m\n" + ] + } + ], + "source": [ + "from typing import Annotated, Literal\n", + "\n", + "from autogen import ConversableAgent, config_list_from_json, register_function\n", + "\n", + "agentops.start_session(tags=[\"autogen-tool-example\"])\n", + "\n", + "Operator = Literal[\"+\", \"-\", \"*\", \"/\"]\n", + "\n", + "\n", + "def calculator(a: int, b: int, operator: Annotated[Operator, \"operator\"]) -> int:\n", + " if operator == \"+\":\n", + " return a + b\n", + " elif operator == \"-\":\n", + " return a - b\n", + " elif operator == \"*\":\n", + " return a * b\n", + " elif operator == \"/\":\n", + " return int(a / b)\n", + " else:\n", + " raise ValueError(\"Invalid operator\")\n", + "\n", + "\n", + "config_list = config_list_from_json(env_or_file=\"OAI_CONFIG_LIST\")\n", + "\n", + "# Create the agent that uses the LLM.\n", + "assistant = ConversableAgent(\n", + " name=\"Assistant\",\n", + " system_message=\"You are a helpful AI assistant. \"\n", + " \"You can help with simple calculations. \"\n", + " \"Return 'TERMINATE' when the task is done.\",\n", + " llm_config={\"config_list\": config_list, \"cache_seed\": None},\n", + ")\n", + "\n", + "# The user proxy agent is used for interacting with the assistant agent\n", + "# and executes tool calls.\n", + "user_proxy = ConversableAgent(\n", + " name=\"User\",\n", + " llm_config=False,\n", + " is_termination_msg=lambda msg: msg.get(\"content\") is not None\n", + " and \"TERMINATE\" in msg[\"content\"],\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "assistant.register_for_llm(name=\"calculator\", description=\"A simple calculator\")(\n", + " calculator\n", + ")\n", + "user_proxy.register_for_execution(name=\"calculator\")(calculator)\n", + "\n", + "# Register the calculator function to the two agents.\n", + "register_function(\n", + " calculator,\n", + " caller=assistant, # The assistant agent can suggest calls to the calculator.\n", + " executor=user_proxy, # The user proxy agent can execute the calculator calls.\n", + " name=\"calculator\", # By default, the function name is used as the tool name.\n", + " description=\"A simple calculator\", # A description of the tool.\n", + ")\n", + "\n", + "# Let the assistant start the conversation. It will end when the user types \"exit\".\n", + "user_proxy.initiate_chat(assistant, message=\"What is (1423 - 123) / 3 + (32 + 23) * 5?\")\n", + "\n", + "agentops.end_session(\"Success\")" + ] + }, + { + "cell_type": "markdown", + "id": "2b4edf8e70d17267", + "metadata": {}, + "source": [ + "You can see your run in action at [app.agentops.ai](https://app.agentops.ai). In this example, the AgentOps dashboard will show:\n", + "- Agents talking to each other\n", + "- Each use of the `calculator` tool\n", + "- Each call to OpenAI for LLM use" + ] + }, + { + "cell_type": "markdown", + "id": "a922a52ab5fce31", + "metadata": { + "collapsed": false + }, + "source": [ + "![Session Drilldown](https://github.com/AgentOps-AI/agentops/blob/main/docs/images/external/app_screenshots/session-replay.png?raw=true)" + ] + } + ], + "metadata": { + "front_matter": { + "description": "Use AgentOps to simplify the development process and monitor your agents in production.", + "tags": [ + "monitoring", + "debugging" + ] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/core_manual_tests/api_server/client.py b/tests/core_manual_tests/api_server/client.py new file mode 100644 index 00000000..6187d21a --- /dev/null +++ b/tests/core_manual_tests/api_server/client.py @@ -0,0 +1,18 @@ +import concurrent.futures +import requests + + +def fetch_url(url): + response = requests.get(url) + return response + + +url = "http://localhost:9696/completion" + +with concurrent.futures.ThreadPoolExecutor() as executor: + futures = [executor.submit(fetch_url, url), executor.submit(fetch_url, url)] + responses = [future.result() for future in concurrent.futures.as_completed(futures)] + +response1, response2 = responses +print(response1.text) +print(response2.text) diff --git a/tests/core_manual_tests/api_server/readme.md b/tests/core_manual_tests/api_server/readme.md new file mode 100644 index 00000000..3f32804d --- /dev/null +++ b/tests/core_manual_tests/api_server/readme.md @@ -0,0 +1,14 @@ +# API server test +This is a manual test with two files. It checks to make sure that the SDK works in an API environment. + +## Running +1. `python server.py` +2. In different terminal, `python client.py` + +## Validate +Check in your AgentOps Dashboard + +1. two sessions are created with the `api-server-test` tag. +2. Each session should have one `LLMEvent` and one `ActionEvent`. +3. Both sessions should have an end state of `Success` +4. Neither session should have multiple agents \ No newline at end of file diff --git a/tests/core_manual_tests/api_server/server.py b/tests/core_manual_tests/api_server/server.py new file mode 100644 index 00000000..61ee8c67 --- /dev/null +++ b/tests/core_manual_tests/api_server/server.py @@ -0,0 +1,40 @@ +import agentops +from fastapi import FastAPI +import uvicorn +from dotenv import load_dotenv +from agentops import ActionEvent +from openai import OpenAI + +load_dotenv() + +openai = OpenAI() +agentops.init() +app = FastAPI() + + +@app.get("/completion") +def completion(): + + session = agentops.start_session(tags=["api-server-test"]) + + messages = [{"role": "user", "content": "Hello"}] + response = session.patch(openai.chat.completions.create)( + model="gpt-3.5-turbo", + messages=messages, + temperature=0.5, + ) + + session.record( + ActionEvent( + action_type="Agent says hello", + params=messages, + returns=str(response.choices[0].message.content), + ), + ) + + session.end_session(end_state="Success") + + return {"response": response} + + +uvicorn.run(app, host="0.0.0.0", port=9696) diff --git a/tests/core_manual_tests/multi_session_llm.py b/tests/core_manual_tests/multi_session_llm.py new file mode 100644 index 00000000..25a652ae --- /dev/null +++ b/tests/core_manual_tests/multi_session_llm.py @@ -0,0 +1,37 @@ +import agentops +from openai import OpenAI +from dotenv import load_dotenv +from agentops import ActionEvent + +load_dotenv() +agentops.init(auto_start_session=False) +openai = OpenAI() + +session_1 = agentops.start_session(tags=["multi-session-test-1"]) +session_2 = agentops.start_session(tags=["multi-session-test-2"]) + +print("session_id_1: {}".format(session_1)) +print("session_id_2: {}".format(session_2)) + +messages = [{"role": "user", "content": "Hello"}] + +# option 1: use session.patch +response = session_1.patch(openai.chat.completions.create)( + model="gpt-3.5-turbo", + messages=messages, + temperature=0.5, +) + +session_1.record(ActionEvent(action_type="test event")) + +# option 2: add session as a keyword argument +response2 = openai.chat.completions.create( + model="gpt-3.5-turbo", messages=messages, temperature=0.5, session=session_2 +) + +session_1.end_session(end_state="Success") +session_2.end_session(end_state="Success") + +### +# Used to verify that two sessions are created, each with one LLM event +### diff --git a/tests/test_canary.py b/tests/test_canary.py index 3db38e11..57ff58c3 100644 --- a/tests/test_canary.py +++ b/tests/test_canary.py @@ -4,6 +4,14 @@ import time import agentops from agentops import ActionEvent +from agentops.helpers import clear_singletons + + +@pytest.fixture(autouse=True) +def setup_teardown(): + clear_singletons() + yield + agentops.end_all_sessions() # teardown part @pytest.fixture diff --git a/tests/test_events.py b/tests/test_events.py index d12c861c..6f41f580 100644 --- a/tests/test_events.py +++ b/tests/test_events.py @@ -3,6 +3,14 @@ import pytest import agentops from agentops import ActionEvent, ErrorEvent +from agentops.helpers import clear_singletons + + +@pytest.fixture(autouse=True) +def setup_teardown(): + clear_singletons() + yield + agentops.end_all_sessions() # teardown part @pytest.fixture @@ -22,7 +30,7 @@ class TestEvents: def setup_method(self): self.api_key = "random_api_key" self.event_type = "test_event_type" - self.config = agentops.Configuration( + self.config = agentops.ClientConfiguration( api_key=self.api_key, max_wait_time=50, max_queue_size=1 ) diff --git a/tests/test_record_function.py b/tests/test_record_function.py index 9be6eef6..24ebeb60 100644 --- a/tests/test_record_function.py +++ b/tests/test_record_function.py @@ -4,18 +4,38 @@ import agentops from agentops import record_function from datetime import datetime +from agentops.helpers import clear_singletons +import contextlib +jwts = ["some_jwt", "some_jwt2", "some_jwt3"] -@pytest.fixture + +@pytest.fixture(autouse=True) +def setup_teardown(): + clear_singletons() + yield + agentops.end_all_sessions() # teardown part + + +@contextlib.contextmanager +@pytest.fixture(autouse=True) def mock_req(): with requests_mock.Mocker() as m: url = "https://api.agentops.ai" m.post(url + "/v2/create_events", text="ok") - m.post( - url + "/v2/create_session", json={"status": "success", "jwt": "some_jwt"} - ) + + # Use iter to create an iterator that can return the jwt values + jwt_tokens = iter(jwts) + + # Use an inner function to change the response for each request + def create_session_response(request, context): + context.status_code = 200 + return {"status": "success", "jwt": next(jwt_tokens)} + + m.post(url + "/v2/create_session", json=create_session_response) m.post(url + "/v2/update_session", json={"status": "success", "token_cost": 5}) m.post(url + "/v2/developer_errors", text="ok") + yield m @@ -93,6 +113,7 @@ async def async_add(x, y): assert request_json["events"][0]["action_type"] == self.event_type assert request_json["events"][0]["params"] == {"x": 3, "y": 4} assert request_json["events"][0]["returns"] == 7 + init = datetime.fromisoformat( request_json["events"][0]["init_timestamp"].replace("Z", "+00:00") ) @@ -103,3 +124,104 @@ async def async_add(x, y): assert (end - init).total_seconds() >= 0.1 agentops.end_session(end_state="Success") + + def test_multiple_sessions_sync(self, mock_req): + session_1 = agentops.start_session() + session_2 = agentops.start_session() + + # Arrange + @record_function(event_name=self.event_type) + def add_three(x, y, z=3): + return x + y + z + + # Act + add_three(1, 2, session=session_1) + time.sleep(0.1) + add_three(1, 2, session=session_2) + time.sleep(0.1) + + # Assert + assert len(mock_req.request_history) == 4 + + request_json = mock_req.last_request.json() + assert mock_req.last_request.headers["X-Agentops-Api-Key"] == self.api_key + assert mock_req.last_request.headers["Authorization"] == f"Bearer some_jwt2" + assert request_json["events"][0]["action_type"] == self.event_type + assert request_json["events"][0]["params"] == {"x": 1, "y": 2, "z": 3} + assert request_json["events"][0]["returns"] == 6 + + second_last_request_json = mock_req.request_history[-2].json() + assert ( + mock_req.request_history[-2].headers["X-Agentops-Api-Key"] == self.api_key + ) + assert ( + mock_req.request_history[-2].headers["Authorization"] == f"Bearer some_jwt" + ) + assert second_last_request_json["events"][0]["action_type"] == self.event_type + assert second_last_request_json["events"][0]["params"] == { + "x": 1, + "y": 2, + "z": 3, + } + assert second_last_request_json["events"][0]["returns"] == 6 + + session_1.end_session(end_state="Success") + session_2.end_session(end_state="Success") + + @pytest.mark.asyncio + async def test_multiple_sessions_async(self, mock_req): + session_1 = agentops.start_session() + session_2 = agentops.start_session() + + # Arrange + @record_function(self.event_type) + async def async_add(x, y): + time.sleep(0.1) + return x + y + + # Act + await async_add(1, 2, session=session_1) + time.sleep(0.1) + await async_add(1, 2, session=session_2) + time.sleep(0.1) + + # Assert + assert len(mock_req.request_history) == 4 + + request_json = mock_req.last_request.json() + assert mock_req.last_request.headers["X-Agentops-Api-Key"] == self.api_key + assert mock_req.last_request.headers["Authorization"] == f"Bearer some_jwt2" + assert request_json["events"][0]["action_type"] == self.event_type + assert request_json["events"][0]["params"] == {"x": 1, "y": 2} + assert request_json["events"][0]["returns"] == 3 + + second_last_request_json = mock_req.request_history[-2].json() + assert ( + mock_req.request_history[-2].headers["X-Agentops-Api-Key"] == self.api_key + ) + assert ( + mock_req.request_history[-2].headers["Authorization"] == f"Bearer some_jwt" + ) + assert second_last_request_json["events"][0]["action_type"] == self.event_type + assert second_last_request_json["events"][0]["params"] == { + "x": 1, + "y": 2, + } + assert second_last_request_json["events"][0]["returns"] == 3 + + session_1.end_session(end_state="Success") + session_2.end_session(end_state="Success") + + def test_require_session_if_multiple(self): + session_1 = agentops.start_session() + session_2 = agentops.start_session() + + # Arrange + @record_function(self.event_type) + def add_two(x, y): + time.sleep(0.1) + return x + y + + with pytest.raises(ValueError): + # Act + add_two(1, 2) diff --git a/tests/test_session.py b/tests/test_session.py index 7148a008..6593de8c 100644 --- a/tests/test_session.py +++ b/tests/test_session.py @@ -2,7 +2,16 @@ import requests_mock import time import agentops -from agentops import ActionEvent +from agentops import ActionEvent, Client +from agentops.exceptions import NoSessionException, MultiSessionException +from agentops.helpers import clear_singletons + + +@pytest.fixture(autouse=True) +def setup_teardown(): + clear_singletons() + yield + agentops.end_all_sessions() # teardown part @pytest.fixture @@ -21,11 +30,13 @@ def mock_req(): yield m -class TestSessions: +class TestSingleSessions: def setup_method(self): self.api_key = "random_api_key" self.event_type = "test_event_type" - self.config = agentops.Configuration(api_key=self.api_key, max_wait_time=50) + self.config = agentops.ClientConfiguration( + api_key=self.api_key, max_wait_time=50 + ) def test_session(self, mock_req): agentops.start_session(config=self.config) @@ -54,6 +65,8 @@ def test_session(self, mock_req): assert request_json["session"]["end_state"] == end_state assert request_json["session"]["tags"] == None + agentops.end_all_sessions() + def test_add_tags(self, mock_req): # Arrange tags = ["GPT-4"] @@ -72,6 +85,8 @@ def test_add_tags(self, mock_req): assert request_json["session"]["end_state"] == end_state assert request_json["session"]["tags"] == ["GPT-4", "test-tag", "dupe-tag"] + agentops.end_all_sessions() + def test_tags(self, mock_req): # Arrange tags = ["GPT-4"] @@ -79,14 +94,6 @@ def test_tags(self, mock_req): # Act agentops.record(ActionEvent(self.event_type)) - time.sleep(0.15) - - # Assert 2 requests - 1 for session init, 1 for event - print(mock_req.last_request.json()) - assert len(mock_req.request_history) == 2 - assert mock_req.last_request.headers["X-Agentops-Api-Key"] == self.api_key - request_json = mock_req.last_request.json() - assert request_json["events"][0]["event_type"] == self.event_type # Act end_state = "Success" @@ -100,6 +107,8 @@ def test_tags(self, mock_req): assert request_json["session"]["end_state"] == end_state assert request_json["session"]["tags"] == tags + agentops.end_all_sessions() + def test_inherit_session_id(self, mock_req): # Arrange inherited_id = "4f72e834-ff26-4802-ba2d-62e7613446f1" @@ -110,13 +119,168 @@ def test_inherit_session_id(self, mock_req): # Act # session_id correct request_json = mock_req.last_request.json() - assert request_json["session_id"] == inherited_id + assert request_json["session"]["session_id"] == inherited_id # Act end_state = "Success" agentops.end_session(end_state) time.sleep(0.15) - # Assert session ended with correct id + agentops.end_all_sessions() + + def test_add_tags_with_string(self, mock_req): + agentops.start_session(config=self.config) + agentops.add_tags("wrong-type-tags") + request_json = mock_req.last_request.json() - assert request_json["session"]["session_id"] == inherited_id + assert request_json["session"]["tags"] == ["wrong-type-tags"] + + def test_session_add_tags_with_string(self, mock_req): + session = agentops.start_session(config=self.config) + session.add_tags("wrong-type-tags") + + request_json = mock_req.last_request.json() + assert request_json["session"]["tags"] == ["wrong-type-tags"] + + def test_set_tags_with_string(self, mock_req): + agentops.start_session(config=self.config) + agentops.set_tags("wrong-type-tags") + + request_json = mock_req.last_request.json() + assert request_json["session"]["tags"] == ["wrong-type-tags"] + + def test_session_set_tags_with_string(self, mock_req): + session = agentops.start_session(config=self.config) + session.set_tags("wrong-type-tags") + + request_json = mock_req.last_request.json() + assert request_json["session"]["tags"] == ["wrong-type-tags"] + + def test_add_tags_before_session(self, mock_req): + agentops.add_tags(["pre-session-tag"]) + agentops.start_session(config=self.config) + + request_json = mock_req.last_request.json() + assert request_json["session"]["tags"] == ["pre-session-tag"] + + def test_set_tags_before_session(self, mock_req): + agentops.set_tags(["pre-session-tag"]) + agentops.start_session(config=self.config) + + request_json = mock_req.last_request.json() + assert request_json["session"]["tags"] == ["pre-session-tag"] + + def test_no_config_doesnt_start_session(self, mock_req): + session = agentops.start_session() + assert session is None + + def test_safe_get_session_no_session(self, mock_req): + with pytest.raises(NoSessionException): + session = Client()._safe_get_session() + + def test_safe_get_session_with_session(self, mock_req): + agentops.start_session(config=self.config) + session = Client()._safe_get_session() + assert session is not None + + def test_safe_get_session_with_multiple_sessions(self, mock_req): + agentops.start_session(config=self.config) + agentops.start_session(config=self.config) + + with pytest.raises(MultiSessionException): + session = Client()._safe_get_session() + + +class TestMultiSessions: + def setup_method(self): + self.api_key = "random_api_key" + self.event_type = "test_event_type" + self.config = agentops.ClientConfiguration( + api_key=self.api_key, max_wait_time=50 + ) + + def test_two_sessions(self, mock_req): + session_1 = agentops.start_session(config=self.config) + session_2 = agentops.start_session(config=self.config) + + assert len(agentops.Client().current_session_ids) == 2 + assert agentops.Client().current_session_ids == [ + str(session_1.session_id), + str(session_2.session_id), + ] + + # We should have 2 requests (session starts). + assert len(mock_req.request_history) == 2 + + session_1.record(ActionEvent(self.event_type)) + session_2.record(ActionEvent(self.event_type)) + + time.sleep(1.5) + + # We should have 4 requests (2 sessions and 2 events each in their own request) + assert len(mock_req.request_history) == 4 + assert mock_req.last_request.headers["Authorization"] == f"Bearer some_jwt" + request_json = mock_req.last_request.json() + assert request_json["events"][0]["event_type"] == self.event_type + + end_state = "Success" + + session_1.end_session(end_state) + time.sleep(1.5) + + # We should have 6 requests (2 additional end sessions) + assert len(mock_req.request_history) == 5 + assert mock_req.last_request.headers["Authorization"] == f"Bearer some_jwt" + request_json = mock_req.last_request.json() + assert request_json["session"]["end_state"] == end_state + assert request_json["session"]["tags"] is None + + session_2.end_session(end_state) + # We should have 6 requests (2 additional end sessions) + assert len(mock_req.request_history) == 6 + assert mock_req.last_request.headers["Authorization"] == f"Bearer some_jwt" + request_json = mock_req.last_request.json() + assert request_json["session"]["end_state"] == end_state + assert request_json["session"]["tags"] is None + + def test_add_tags(self, mock_req): + # Arrange + session_1_tags = ["session-1"] + session_2_tags = ["session-2"] + + session_1 = agentops.start_session(tags=session_1_tags, config=self.config) + session_2 = agentops.start_session(tags=session_2_tags, config=self.config) + + session_1.add_tags(["session-1-added", "session-1-added-2"]) + session_2.add_tags(["session-2-added"]) + + # Act + end_state = "Success" + session_1.end_session(end_state) + session_2.end_session(end_state) + time.sleep(0.15) + + # Assert 3 requests, 1 for session init, 1 for event, 1 for end session + req1 = mock_req.request_history[-1].json() + req2 = mock_req.request_history[-2].json() + + session_1_req = ( + req1 if req1["session"]["session_id"] == session_1.session_id else req2 + ) + session_2_req = ( + req2 if req2["session"]["session_id"] == session_2.session_id else req1 + ) + + assert session_1_req["session"]["end_state"] == end_state + assert session_2_req["session"]["end_state"] == end_state + + assert session_1_req["session"]["tags"] == [ + "session-1", + "session-1-added", + "session-1-added-2", + ] + + assert session_2_req["session"]["tags"] == [ + "session-2", + "session-2-added", + ] diff --git a/tests/test_singleton.py b/tests/test_singleton.py new file mode 100644 index 00000000..ff936c30 --- /dev/null +++ b/tests/test_singleton.py @@ -0,0 +1,41 @@ +import uuid + +import pytest + +from agentops.helpers import singleton, conditional_singleton, clear_singletons + + +@singleton +class SingletonClass: + def __init__(self): + self.id = str(uuid.uuid4()) + + +@conditional_singleton +class ConditionalSingletonClass: + def __init__(self): + self.id = str(uuid.uuid4()) + + +class TestSingleton: + def test_singleton(self): + c1 = SingletonClass() + c2 = SingletonClass() + + assert c1.id == c2.id + + def test_conditional_singleton(self): + c1 = ConditionalSingletonClass() + c2 = ConditionalSingletonClass() + noSingleton = ConditionalSingletonClass(use_singleton=False) + + assert c1.id == c2.id + assert c1.id != noSingleton.id + assert c2.id != noSingleton.id + + def test_clear_singletons(self): + c1 = SingletonClass() + clear_singletons() + c2 = SingletonClass() + + assert c1.id != c2.id