Integrating MemGPT-like Functionality

Makefile

@@ -142,6 +142,7 @@ install-python-dependencies:
 		poetry run pip install chroma-hnswlib; \
 	fi
 	@poetry install
+	@poetry run pip install -q -U google-generativeai
 	@if [ -f "/etc/manjaro-release" ]; then \
 		echo "$(BLUE)Detected Manjaro Linux. Installing Playwright dependencies...$(RESET)"; \
 		poetry run pip install playwright; \

agenthub/codeact_agent/codeact_agent.py

@@ -1,3 +1,7 @@
+#######
+
+from litellm.exceptions import ContextWindowExceededError
+
 from agenthub.codeact_agent.action_parser import CodeActResponseParser
 from agenthub.codeact_agent.prompt import (
     COMMAND_DOCS,
@@ -9,10 +13,16 @@
 from opendevin.controller.agent import Agent
 from opendevin.controller.state.state import State
 from opendevin.core.config import config
+from opendevin.core.exceptions import (
+    ContextWindowLimitExceededError,
+    SummarizeError,
+    TokenLimitExceededError,
+)
 from opendevin.events.action import (
     Action,
     AgentDelegateAction,
     AgentFinishAction,
+    AgentSummarizeAction,
     CmdRunAction,
     IPythonRunCellAction,
     MessageAction,
@@ -24,13 +34,17 @@
 )
 from opendevin.events.serialization.event import truncate_content
 from opendevin.llm.llm import LLM
+from opendevin.memory.condenser import MemoryCondenser
+from opendevin.memory.history import ShortTermHistory
 from opendevin.runtime.plugins import (
     AgentSkillsRequirement,
     JupyterRequirement,
     PluginRequirement,
 )
 from opendevin.runtime.tools import RuntimeTool
 
+#######
+
 ENABLE_GITHUB = True
 
 
@@ -43,6 +57,8 @@ def action_to_str(action: Action) -> str:
         return f'{action.thought}\n<execute_browse>\n{action.inputs["task"]}\n</execute_browse>'
     elif isinstance(action, MessageAction):
         return action.content
+    elif isinstance(action, AgentSummarizeAction):
+        return action.summarized_actions
     return ''
 
 
@@ -52,6 +68,7 @@ def get_action_message(action: Action) -> dict[str, str] | None:
         or isinstance(action, CmdRunAction)
         or isinstance(action, IPythonRunCellAction)
         or isinstance(action, MessageAction)
+        or isinstance(action, AgentSummarizeAction)
     ):
         return {
             'role': 'user' if action.source == 'user' else 'assistant',
@@ -87,6 +104,8 @@ def get_observation_message(obs) -> dict[str, str] | None:
             str(obs.outputs), max_message_chars
         )
         return {'role': 'user', 'content': content}
+    elif isinstance(obs, AgentSummarizeAction):
+        return {'role': 'user', 'content': obs.summarized_observations}
     return None
 
 
@@ -165,6 +184,8 @@ def __init__(
         - llm (LLM): The llm to be used by this agent
         """
         super().__init__(llm)
+        self.memory_condenser = MemoryCondenser(llm)
+        self.attempts_to_condense = 2
         self.reset()
 
     def reset(self) -> None:
@@ -194,27 +215,148 @@ def step(self, state: State) -> Action:
         if latest_user_message and latest_user_message.strip() == '/exit':
             return AgentFinishAction()
 
-        # prepare what we want to send to the LLM
-        messages: list[dict[str, str]] = self._get_messages(state)
-
-        response = self.llm.completion(
-            messages=messages,
-            stop=[
-                '</execute_ipython>',
-                '</execute_bash>',
-                '</execute_browse>',
-            ],
-            temperature=0.0,
-        )
+        response = None
+        # give it multiple chances to get a response
+        # if it fails, we'll try to condense memory
+        attempt = 0
+        while not response and attempt < self.attempts_to_condense:
+            # prepare what we want to send to the LLM
+            messages: list[dict[str, str]] = self._get_messages(state)
+            print('No of tokens, ' + str(self.llm.get_token_count(messages)) + '\n')
+            try:
+                if self.llm.is_over_token_limit(messages):
+                    raise TokenLimitExceededError()
+                response = self.llm.completion(
+                    messages=messages,
+                    stop=[
+                        '</execute_ipython>',
+                        '</execute_bash>',
+                        '</execute_browse>',
+                    ],
+                    temperature=0.0,
+                )
+            except (ContextWindowExceededError, TokenLimitExceededError):
+                # Handle the specific exception
+                print('An error occurred: ')
+                attempt += 1
+                # If we got a context alert, try trimming the messages length, then try again
+                if self.llm.is_over_token_limit(messages):
+                    # A separate call to run a summarizer
+                    self.condense(state=state)
+                    # Try step again
+                else:
+                    print('step() failed with an unrecognized exception:')
+                    raise ContextWindowLimitExceededError()
+
+            # TODO: Manage the response for exception.
         return self.action_parser.parse(response)
 
+    def condense(
+        self,
+        state: State,
+    ):
+        # Start past the system message, and example messages.,
+        # and collect messages for summarization until we reach the desired truncation token fraction (eg 50%)
+        # Do not allow truncation  for in-context examples of function calling
+        history: ShortTermHistory = state.history
+        messages = self._get_messages(state=state)
+        token_counts = [self.llm.get_token_count([message]) for message in messages]
+        message_buffer_token_count = sum(
+            token_counts[2:]
+        )  # no system and example message
+        MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC = 0.75
+        desired_token_count_to_summarize = int(
+            message_buffer_token_count * MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC
+        )
+
+        candidate_messages_to_summarize = []
+        last_summarized_event_id = history.last_summarized_event_id
+        tokens_so_far = 0
+        for event in history.get_events():
+            if isinstance(event, AgentSummarizeAction):
+                action_message = get_action_message(event)
+                if action_message:
+                    candidate_messages_to_summarize.append(action_message)
+                    tokens_so_far += self.llm.get_token_count([action_message])
+                observation_message = get_observation_message(event)
+                if observation_message:
+                    candidate_messages_to_summarize.append(observation_message)
+                    tokens_so_far += self.llm.get_token_count([observation_message])
+                continue
+            else:
+                message = (
+                    get_action_message(event)
+                    if isinstance(event, Action)
+                    else get_observation_message(event)
+                )
+                if message:
+                    candidate_messages_to_summarize.append(message)
+                    tokens_so_far += self.llm.get_token_count([message])
+            if tokens_so_far > desired_token_count_to_summarize:
+                last_summarized_event_id = event.id
+                break
+
+        # TODO: Add functionality for preserving last N messages
+        # MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
+        # if preserve_last_N_messages:
+        #     candidate_messages_to_summarize = candidate_messages_to_summarize[:-MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST]
+        #     token_counts = token_counts[:-MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST]
+
+        print(f'MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC={MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC}')
+        # print(f'MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST={MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST}')
+        print(f'token_counts={token_counts}')
+        print(f'message_buffer_token_count={message_buffer_token_count}')
+        print(f'desired_token_count_to_summarize={desired_token_count_to_summarize}')
+        print(
+            f'len(candidate_messages_to_summarize)={len(candidate_messages_to_summarize)}'
+        )
+
+        if len(candidate_messages_to_summarize) == 0:
+            raise SummarizeError(
+                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(messages)}]"
+            )
+
+        # TODO: Try to make an assistant message come after the cutoff
+
+        message_sequence_to_summarize = candidate_messages_to_summarize
+
+        if len(message_sequence_to_summarize) <= 1:
+            # This prevents a potential infinite loop of summarizing the same message over and over
+            raise SummarizeError(
+                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(message_sequence_to_summarize)} <= 1]"
+            )
+        else:
+            print(
+                f'Attempting to summarize with last summarized event id = {last_summarized_event_id}'
+            )
+
+        summary_action = self.memory_condenser.summarize_messages(
+            message_sequence_to_summarize=message_sequence_to_summarize
+        )
+        summary_action.last_summarized_event_id = last_summarized_event_id
+        print(f'Got summary: {summary_action}')
+        history.add_summary(summary_action)
+        print('Added summary to history')
+
+    def search_memory(self, query: str) -> list[str]:
+        raise NotImplementedError('Implement this abstract method')
+
     def _get_messages(self, state: State) -> list[dict[str, str]]:
         messages = [
             {'role': 'system', 'content': self.system_message},
             {'role': 'user', 'content': self.in_context_example},
         ]
 
         for event in state.history.get_events():
+            if isinstance(event, AgentSummarizeAction):
+                action_message = get_action_message(event)
+                if action_message:
+                    messages.append(action_message)
+                observation_message = get_observation_message(event)
+                if observation_message:
+                    messages.append(observation_message)
+                continue
+
             # create a regular message from an event
             message = (
                 get_action_message(event)

agenthub/monologue_agent/agent.py

@@ -81,7 +81,7 @@ def _initialize(self, task: str):
         else:
             self.memory = None
 
-        self.memory_condenser = MemoryCondenser()
+        self.memory_condenser = MemoryCondenser(llm=self.llm)
 
         self._add_initial_thoughts(task)
         self._initialized = True

opendevin/core/config.py

@@ -60,7 +60,7 @@ class LLMConfig:
     aws_access_key_id: str | None = None
     aws_secret_access_key: str | None = None
     aws_region_name: str | None = None
-    num_retries: int = 5
+    num_retries: int = 15
     retry_min_wait: int = 3
     retry_max_wait: int = 60
     timeout: int | None = None

opendevin/core/exceptions.py

@@ -67,3 +67,29 @@ def __init__(self, message='Agent must return an action'):
 class LLMResponseError(Exception):
     def __init__(self, message='Failed to retrieve action from LLM response'):
         super().__init__(message)
+
+
+class TokenLimitExceededError(Exception):
+    """Exception raised when the user-defined max_input_tokens limit is exceeded."""
+
+    def __init__(self, message='User-defined token limit exceeded. Condensing memory.'):
+        super().__init__(message)
+
+
+class ContextWindowLimitExceededError(Exception):
+    def __init__(
+        self, message='Context window limit exceeded. Unable to condense memory.'
+    ):
+        super().__init__(message)
+
+
+class SummarizeError(Exception):
+    """Exception raised when message can't be Summarized."""
+
+    def __init__(self, message='Error Summarizing The Memory'):
+        super().__init__(message)
+
+
+class InvalidSummaryResponseError(Exception):
+    def __init__(self, message='Invalid summary response'):
+        super().__init__(message)

opendevin/events/action/agent.py

@@ -18,18 +18,49 @@ def message(self) -> str:
         return f'Agent state changed to {self.agent_state}'
 
 
+# @dataclass
+# class AgentSummarizeAction(Action):
+#     summary: str
+#     action: str = ActionType.SUMMARIZE
+#     _chunk_start: int = -1
+#     _chunk_end: int = -1
+
+#     @property
+#     def message(self) -> str:
+#         return self.summary
+
+#     def __str__(self) -> str:
+#         ret = '**AgentSummarizeAction**\n'
+#         ret += f'SUMMARY: {self.summary}'
+#         return
+
+
 @dataclass
 class AgentSummarizeAction(Action):
-    summary: str
+    """
+    Action to summarize a list of events.
+
+    Attributes:
+    - summarized_actions: A sentence summarizing all the actions.
+    - summarized_observations: A few sentences summarizing all the observations.
+    """
+
+    summarized_actions: str = ''
+    summarized_observations: str = ''
     action: str = ActionType.SUMMARIZE
+    # _chunk_start: int = -1
+    # _chunk_end: int = -1
+    last_summarized_event_id = None
+    is_delegate_summary: bool = False
 
     @property
     def message(self) -> str:
-        return self.summary
+        return self.summarized_observations
 
     def __str__(self) -> str:
         ret = '**AgentSummarizeAction**\n'
-        ret += f'SUMMARY: {self.summary}'
+        ret += f'SUMMARIZED ACTIONS: {self.summarized_actions}\n'
+        ret += f'SUMMARIZED OBSERVATIONS: {self.summarized_observations}\n'
         return ret
 
 

opendevin/events/serialization/action.py

@@ -4,6 +4,7 @@
     AgentDelegateAction,
     AgentFinishAction,
     AgentRejectAction,
+    AgentSummarizeAction,
     ChangeAgentStateAction,
 )
 from opendevin.events.action.browse import BrowseInteractiveAction, BrowseURLAction
@@ -31,6 +32,7 @@
     ModifyTaskAction,
     ChangeAgentStateAction,
     MessageAction,
+    AgentSummarizeAction,
 )
 
 ACTION_TYPE_TO_CLASS = {action_class.action: action_class for action_class in actions}  # type: ignore[attr-defined]