forked from Archives/langchain
Move Generative Agent definition to Experimental (#3245)
Extending @BeautyyuYanli 's #3220 to move from the notebook --------- Co-authored-by: BeautyyuYanli <beautyyuyanli@gmail.com>fix_agent_callbacks
parent
20f530e9c5
commit
738ee56b86
@ -0,0 +1,28 @@
|
|||||||
|
==========
|
||||||
|
Experimental Modules
|
||||||
|
==========
|
||||||
|
|
||||||
|
This module contains experimental modules and reproductions of existing work using LangChain primitives.
|
||||||
|
|
||||||
|
Autonomous Agents
|
||||||
|
------------------
|
||||||
|
|
||||||
|
Here, we document the BabyAGI and AutoGPT classes from the langchain.experimental module.
|
||||||
|
|
||||||
|
.. autoclass:: langchain.experimental.BabyAGI
|
||||||
|
:members:
|
||||||
|
|
||||||
|
.. autoclass:: langchain.experimental.AutoGPT
|
||||||
|
:members:
|
||||||
|
|
||||||
|
|
||||||
|
Generative Agents
|
||||||
|
------------------
|
||||||
|
|
||||||
|
Here, we document the GenerativeAgent and GenerativeAgentMemory classes from the langchain.experimental module.
|
||||||
|
|
||||||
|
.. autoclass:: langchain.experimental.GenerativeAgent
|
||||||
|
:members:
|
||||||
|
|
||||||
|
.. autoclass:: langchain.experimental.GenerativeAgentMemory
|
||||||
|
:members:
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,4 +1,6 @@
|
|||||||
from langchain.experimental.autonomous_agents.autogpt.agent import AutoGPT
|
from langchain.experimental.autonomous_agents.autogpt.agent import AutoGPT
|
||||||
from langchain.experimental.autonomous_agents.baby_agi.baby_agi import BabyAGI
|
from langchain.experimental.autonomous_agents.baby_agi.baby_agi import BabyAGI
|
||||||
|
from langchain.experimental.generative_agents.generative_agent import GenerativeAgent
|
||||||
|
from langchain.experimental.generative_agents.memory import GenerativeAgentMemory
|
||||||
|
|
||||||
__all__ = ["BabyAGI", "AutoGPT"]
|
__all__ = ["BabyAGI", "AutoGPT", "GenerativeAgent", "GenerativeAgentMemory"]
|
||||||
|
@ -0,0 +1,5 @@
|
|||||||
|
"""Generative Agents primitives."""
|
||||||
|
from langchain.experimental.generative_agents.generative_agent import GenerativeAgent
|
||||||
|
from langchain.experimental.generative_agents.memory import GenerativeAgentMemory
|
||||||
|
|
||||||
|
__all__ = ["GenerativeAgent", "GenerativeAgentMemory"]
|
@ -0,0 +1,230 @@
|
|||||||
|
import re
|
||||||
|
from datetime import datetime
|
||||||
|
from typing import Any, Dict, List, Optional, Tuple
|
||||||
|
|
||||||
|
from pydantic import BaseModel, Field
|
||||||
|
|
||||||
|
from langchain import LLMChain
|
||||||
|
from langchain.experimental.generative_agents.memory import GenerativeAgentMemory
|
||||||
|
from langchain.prompts import PromptTemplate
|
||||||
|
from langchain.schema import BaseLanguageModel
|
||||||
|
|
||||||
|
|
||||||
|
class GenerativeAgent(BaseModel):
|
||||||
|
"""A character with memory and innate characteristics."""
|
||||||
|
|
||||||
|
name: str
|
||||||
|
"""The character's name."""
|
||||||
|
|
||||||
|
age: Optional[int] = None
|
||||||
|
"""The optional age of the character."""
|
||||||
|
traits: str = "N/A"
|
||||||
|
"""Permanent traits to ascribe to the character."""
|
||||||
|
status: str
|
||||||
|
"""The traits of the character you wish not to change."""
|
||||||
|
memory: GenerativeAgentMemory
|
||||||
|
"""The memory object that combines relevance, recency, and 'importance'."""
|
||||||
|
llm: BaseLanguageModel
|
||||||
|
"""The underlying language model."""
|
||||||
|
verbose: bool = False
|
||||||
|
summary: str = "" #: :meta private:
|
||||||
|
"""Stateful self-summary generated via reflection on the character's memory."""
|
||||||
|
|
||||||
|
summary_refresh_seconds: int = 3600 #: :meta private:
|
||||||
|
"""How frequently to re-generate the summary."""
|
||||||
|
|
||||||
|
last_refreshed: datetime = Field(default_factory=datetime.now) # : :meta private:
|
||||||
|
"""The last time the character's summary was regenerated."""
|
||||||
|
|
||||||
|
daily_summaries: List[str] = Field(default_factory=list) # : :meta private:
|
||||||
|
"""Summary of the events in the plan that the agent took."""
|
||||||
|
|
||||||
|
class Config:
|
||||||
|
"""Configuration for this pydantic object."""
|
||||||
|
|
||||||
|
arbitrary_types_allowed = True
|
||||||
|
|
||||||
|
# LLM-related methods
|
||||||
|
@staticmethod
|
||||||
|
def _parse_list(text: str) -> List[str]:
|
||||||
|
"""Parse a newline-separated string into a list of strings."""
|
||||||
|
lines = re.split(r"\n", text.strip())
|
||||||
|
return [re.sub(r"^\s*\d+\.\s*", "", line).strip() for line in lines]
|
||||||
|
|
||||||
|
def chain(self, prompt: PromptTemplate) -> LLMChain:
|
||||||
|
return LLMChain(
|
||||||
|
llm=self.llm, prompt=prompt, verbose=self.verbose, memory=self.memory
|
||||||
|
)
|
||||||
|
|
||||||
|
def _get_entity_from_observation(self, observation: str) -> str:
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"What is the observed entity in the following observation? {observation}"
|
||||||
|
+ "\nEntity="
|
||||||
|
)
|
||||||
|
return self.chain(prompt).run(observation=observation).strip()
|
||||||
|
|
||||||
|
def _get_entity_action(self, observation: str, entity_name: str) -> str:
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"What is the {entity} doing in the following observation? {observation}"
|
||||||
|
+ "\nThe {entity} is"
|
||||||
|
)
|
||||||
|
return (
|
||||||
|
self.chain(prompt).run(entity=entity_name, observation=observation).strip()
|
||||||
|
)
|
||||||
|
|
||||||
|
def summarize_related_memories(self, observation: str) -> str:
|
||||||
|
"""Summarize memories that are most relevant to an observation."""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"""
|
||||||
|
{q1}?
|
||||||
|
Context from memory:
|
||||||
|
{relevant_memories}
|
||||||
|
Relevant context:
|
||||||
|
"""
|
||||||
|
)
|
||||||
|
entity_name = self._get_entity_from_observation(observation)
|
||||||
|
entity_action = self._get_entity_action(observation, entity_name)
|
||||||
|
q1 = f"What is the relationship between {self.name} and {entity_name}"
|
||||||
|
q2 = f"{entity_name} is {entity_action}"
|
||||||
|
return self.chain(prompt=prompt).run(q1=q1, queries=[q1, q2]).strip()
|
||||||
|
|
||||||
|
def _generate_reaction(self, observation: str, suffix: str) -> str:
|
||||||
|
"""React to a given observation or dialogue act."""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"{agent_summary_description}"
|
||||||
|
+ "\nIt is {current_time}."
|
||||||
|
+ "\n{agent_name}'s status: {agent_status}"
|
||||||
|
+ "\nSummary of relevant context from {agent_name}'s memory:"
|
||||||
|
+ "\n{relevant_memories}"
|
||||||
|
+ "\nMost recent observations: {most_recent_memories}"
|
||||||
|
+ "\nObservation: {observation}"
|
||||||
|
+ "\n\n"
|
||||||
|
+ suffix
|
||||||
|
)
|
||||||
|
agent_summary_description = self.get_summary()
|
||||||
|
relevant_memories_str = self.summarize_related_memories(observation)
|
||||||
|
current_time_str = datetime.now().strftime("%B %d, %Y, %I:%M %p")
|
||||||
|
kwargs: Dict[str, Any] = dict(
|
||||||
|
agent_summary_description=agent_summary_description,
|
||||||
|
current_time=current_time_str,
|
||||||
|
relevant_memories=relevant_memories_str,
|
||||||
|
agent_name=self.name,
|
||||||
|
observation=observation,
|
||||||
|
agent_status=self.status,
|
||||||
|
)
|
||||||
|
consumed_tokens = self.llm.get_num_tokens(
|
||||||
|
prompt.format(most_recent_memories="", **kwargs)
|
||||||
|
)
|
||||||
|
kwargs[self.memory.most_recent_memories_token_key] = consumed_tokens
|
||||||
|
return self.chain(prompt=prompt).run(**kwargs).strip()
|
||||||
|
|
||||||
|
def _clean_response(self, text: str) -> str:
|
||||||
|
return re.sub(f"^{self.name} ", "", text.strip()).strip()
|
||||||
|
|
||||||
|
def generate_reaction(self, observation: str) -> Tuple[bool, str]:
|
||||||
|
"""React to a given observation."""
|
||||||
|
call_to_action_template = (
|
||||||
|
"Should {agent_name} react to the observation, and if so,"
|
||||||
|
+ " what would be an appropriate reaction? Respond in one line."
|
||||||
|
+ ' If the action is to engage in dialogue, write:\nSAY: "what to say"'
|
||||||
|
+ "\notherwise, write:\nREACT: {agent_name}'s reaction (if anything)."
|
||||||
|
+ "\nEither do nothing, react, or say something but not both.\n\n"
|
||||||
|
)
|
||||||
|
full_result = self._generate_reaction(observation, call_to_action_template)
|
||||||
|
result = full_result.strip().split("\n")[0]
|
||||||
|
# AAA
|
||||||
|
self.memory.save_context(
|
||||||
|
{},
|
||||||
|
{
|
||||||
|
self.memory.add_memory_key: f"{self.name} observed "
|
||||||
|
f"{observation} and reacted by {result}"
|
||||||
|
},
|
||||||
|
)
|
||||||
|
if "REACT:" in result:
|
||||||
|
reaction = self._clean_response(result.split("REACT:")[-1])
|
||||||
|
return False, f"{self.name} {reaction}"
|
||||||
|
if "SAY:" in result:
|
||||||
|
said_value = self._clean_response(result.split("SAY:")[-1])
|
||||||
|
return True, f"{self.name} said {said_value}"
|
||||||
|
else:
|
||||||
|
return False, result
|
||||||
|
|
||||||
|
def generate_dialogue_response(self, observation: str) -> Tuple[bool, str]:
|
||||||
|
"""React to a given observation."""
|
||||||
|
call_to_action_template = (
|
||||||
|
"What would {agent_name} say? To end the conversation, write:"
|
||||||
|
' GOODBYE: "what to say". Otherwise to continue the conversation,'
|
||||||
|
' write: SAY: "what to say next"\n\n'
|
||||||
|
)
|
||||||
|
full_result = self._generate_reaction(observation, call_to_action_template)
|
||||||
|
result = full_result.strip().split("\n")[0]
|
||||||
|
if "GOODBYE:" in result:
|
||||||
|
farewell = self._clean_response(result.split("GOODBYE:")[-1])
|
||||||
|
self.memory.save_context(
|
||||||
|
{},
|
||||||
|
{
|
||||||
|
self.memory.add_memory_key: f"{self.name} observed "
|
||||||
|
f"{observation} and said {farewell}"
|
||||||
|
},
|
||||||
|
)
|
||||||
|
return False, f"{self.name} said {farewell}"
|
||||||
|
if "SAY:" in result:
|
||||||
|
response_text = self._clean_response(result.split("SAY:")[-1])
|
||||||
|
self.memory.save_context(
|
||||||
|
{},
|
||||||
|
{
|
||||||
|
self.memory.add_memory_key: f"{self.name} observed "
|
||||||
|
f"{observation} and said {response_text}"
|
||||||
|
},
|
||||||
|
)
|
||||||
|
return True, f"{self.name} said {response_text}"
|
||||||
|
else:
|
||||||
|
return False, result
|
||||||
|
|
||||||
|
######################################################
|
||||||
|
# Agent stateful' summary methods. #
|
||||||
|
# Each dialog or response prompt includes a header #
|
||||||
|
# summarizing the agent's self-description. This is #
|
||||||
|
# updated periodically through probing its memories #
|
||||||
|
######################################################
|
||||||
|
def _compute_agent_summary(self) -> str:
|
||||||
|
""""""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"How would you summarize {name}'s core characteristics given the"
|
||||||
|
+ " following statements:\n"
|
||||||
|
+ "{relevant_memories}"
|
||||||
|
+ "Do not embellish."
|
||||||
|
+ "\n\nSummary: "
|
||||||
|
)
|
||||||
|
# The agent seeks to think about their core characteristics.
|
||||||
|
return (
|
||||||
|
self.chain(prompt)
|
||||||
|
.run(name=self.name, queries=[f"{self.name}'s core characteristics"])
|
||||||
|
.strip()
|
||||||
|
)
|
||||||
|
|
||||||
|
def get_summary(self, force_refresh: bool = False) -> str:
|
||||||
|
"""Return a descriptive summary of the agent."""
|
||||||
|
current_time = datetime.now()
|
||||||
|
since_refresh = (current_time - self.last_refreshed).seconds
|
||||||
|
if (
|
||||||
|
not self.summary
|
||||||
|
or since_refresh >= self.summary_refresh_seconds
|
||||||
|
or force_refresh
|
||||||
|
):
|
||||||
|
self.summary = self._compute_agent_summary()
|
||||||
|
self.last_refreshed = current_time
|
||||||
|
age = self.age if self.age is not None else "N/A"
|
||||||
|
return (
|
||||||
|
f"Name: {self.name} (age: {age})"
|
||||||
|
+ f"\nInnate traits: {self.traits}"
|
||||||
|
+ f"\n{self.summary}"
|
||||||
|
)
|
||||||
|
|
||||||
|
def get_full_header(self, force_refresh: bool = False) -> str:
|
||||||
|
"""Return a full header of the agent's status, summary, and current time."""
|
||||||
|
summary = self.get_summary(force_refresh=force_refresh)
|
||||||
|
current_time_str = datetime.now().strftime("%B %d, %Y, %I:%M %p")
|
||||||
|
return (
|
||||||
|
f"{summary}\nIt is {current_time_str}.\n{self.name}'s status: {self.status}"
|
||||||
|
)
|
@ -0,0 +1,212 @@
|
|||||||
|
import logging
|
||||||
|
import re
|
||||||
|
from typing import Any, Dict, List, Optional
|
||||||
|
|
||||||
|
from langchain import LLMChain
|
||||||
|
from langchain.prompts import PromptTemplate
|
||||||
|
from langchain.retrievers import TimeWeightedVectorStoreRetriever
|
||||||
|
from langchain.schema import BaseLanguageModel, BaseMemory, Document
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
|
||||||
|
class GenerativeAgentMemory(BaseMemory):
|
||||||
|
llm: BaseLanguageModel
|
||||||
|
"""The core language model."""
|
||||||
|
|
||||||
|
memory_retriever: TimeWeightedVectorStoreRetriever
|
||||||
|
"""The retriever to fetch related memories."""
|
||||||
|
verbose: bool = False
|
||||||
|
|
||||||
|
reflection_threshold: Optional[float] = None
|
||||||
|
"""When aggregate_importance exceeds reflection_threshold, stop to reflect."""
|
||||||
|
|
||||||
|
current_plan: List[str] = []
|
||||||
|
"""The current plan of the agent."""
|
||||||
|
|
||||||
|
# A weight of 0.15 makes this less important than it
|
||||||
|
# would be otherwise, relative to salience and time
|
||||||
|
importance_weight: float = 0.15
|
||||||
|
"""How much weight to assign the memory importance."""
|
||||||
|
|
||||||
|
aggregate_importance: float = 0.0 # : :meta private:
|
||||||
|
"""Track the sum of the 'importance' of recent memories.
|
||||||
|
|
||||||
|
Triggers reflection when it reaches reflection_threshold."""
|
||||||
|
|
||||||
|
max_tokens_limit: int = 1200 # : :meta private:
|
||||||
|
# input keys
|
||||||
|
queries_key: str = "queries"
|
||||||
|
most_recent_memories_token_key: str = "recent_memories_token"
|
||||||
|
add_memory_key: str = "add_memory"
|
||||||
|
# output keys
|
||||||
|
relevant_memories_key: str = "relevant_memories"
|
||||||
|
relevant_memories_simple_key: str = "relevant_memories_simple"
|
||||||
|
most_recent_memories_key: str = "most_recent_memories"
|
||||||
|
|
||||||
|
def chain(self, prompt: PromptTemplate) -> LLMChain:
|
||||||
|
return LLMChain(llm=self.llm, prompt=prompt, verbose=self.verbose)
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _parse_list(text: str) -> List[str]:
|
||||||
|
"""Parse a newline-separated string into a list of strings."""
|
||||||
|
lines = re.split(r"\n", text.strip())
|
||||||
|
return [re.sub(r"^\s*\d+\.\s*", "", line).strip() for line in lines]
|
||||||
|
|
||||||
|
def _get_topics_of_reflection(self, last_k: int = 50) -> List[str]:
|
||||||
|
"""Return the 3 most salient high-level questions about recent observations."""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"{observations}\n\n"
|
||||||
|
+ "Given only the information above, what are the 3 most salient"
|
||||||
|
+ " high-level questions we can answer about the subjects in"
|
||||||
|
+ " the statements? Provide each question on a new line.\n\n"
|
||||||
|
)
|
||||||
|
observations = self.memory_retriever.memory_stream[-last_k:]
|
||||||
|
observation_str = "\n".join([o.page_content for o in observations])
|
||||||
|
result = self.chain(prompt).run(observations=observation_str)
|
||||||
|
return self._parse_list(result)
|
||||||
|
|
||||||
|
def _get_insights_on_topic(self, topic: str) -> List[str]:
|
||||||
|
"""Generate 'insights' on a topic of reflection, based on pertinent memories."""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"Statements about {topic}\n"
|
||||||
|
+ "{related_statements}\n\n"
|
||||||
|
+ "What 5 high-level insights can you infer from the above statements?"
|
||||||
|
+ " (example format: insight (because of 1, 5, 3))"
|
||||||
|
)
|
||||||
|
related_memories = self.fetch_memories(topic)
|
||||||
|
related_statements = "\n".join(
|
||||||
|
[
|
||||||
|
f"{i+1}. {memory.page_content}"
|
||||||
|
for i, memory in enumerate(related_memories)
|
||||||
|
]
|
||||||
|
)
|
||||||
|
result = self.chain(prompt).run(
|
||||||
|
topic=topic, related_statements=related_statements
|
||||||
|
)
|
||||||
|
# TODO: Parse the connections between memories and insights
|
||||||
|
return self._parse_list(result)
|
||||||
|
|
||||||
|
def pause_to_reflect(self) -> List[str]:
|
||||||
|
"""Reflect on recent observations and generate 'insights'."""
|
||||||
|
if self.verbose:
|
||||||
|
logger.info("Character is reflecting")
|
||||||
|
new_insights = []
|
||||||
|
topics = self._get_topics_of_reflection()
|
||||||
|
for topic in topics:
|
||||||
|
insights = self._get_insights_on_topic(topic)
|
||||||
|
for insight in insights:
|
||||||
|
self.add_memory(insight)
|
||||||
|
new_insights.extend(insights)
|
||||||
|
return new_insights
|
||||||
|
|
||||||
|
def _score_memory_importance(self, memory_content: str) -> float:
|
||||||
|
"""Score the absolute importance of the given memory."""
|
||||||
|
prompt = PromptTemplate.from_template(
|
||||||
|
"On the scale of 1 to 10, where 1 is purely mundane"
|
||||||
|
+ " (e.g., brushing teeth, making bed) and 10 is"
|
||||||
|
+ " extremely poignant (e.g., a break up, college"
|
||||||
|
+ " acceptance), rate the likely poignancy of the"
|
||||||
|
+ " following piece of memory. Respond with a single integer."
|
||||||
|
+ "\nMemory: {memory_content}"
|
||||||
|
+ "\nRating: "
|
||||||
|
)
|
||||||
|
score = self.chain(prompt).run(memory_content=memory_content).strip()
|
||||||
|
if self.verbose:
|
||||||
|
logger.info(f"Importance score: {score}")
|
||||||
|
match = re.search(r"^\D*(\d+)", score)
|
||||||
|
if match:
|
||||||
|
return (float(score[0]) / 10) * self.importance_weight
|
||||||
|
else:
|
||||||
|
return 0.0
|
||||||
|
|
||||||
|
def add_memory(self, memory_content: str) -> List[str]:
|
||||||
|
"""Add an observation or memory to the agent's memory."""
|
||||||
|
importance_score = self._score_memory_importance(memory_content)
|
||||||
|
self.aggregate_importance += importance_score
|
||||||
|
document = Document(
|
||||||
|
page_content=memory_content, metadata={"importance": importance_score}
|
||||||
|
)
|
||||||
|
result = self.memory_retriever.add_documents([document])
|
||||||
|
|
||||||
|
# After an agent has processed a certain amount of memories (as measured by
|
||||||
|
# aggregate importance), it is time to reflect on recent events to add
|
||||||
|
# more synthesized memories to the agent's memory stream.
|
||||||
|
if (
|
||||||
|
self.reflection_threshold is not None
|
||||||
|
and self.aggregate_importance > self.reflection_threshold
|
||||||
|
):
|
||||||
|
self.pause_to_reflect()
|
||||||
|
# Hack to clear the importance from reflection
|
||||||
|
self.aggregate_importance = 0.0
|
||||||
|
return result
|
||||||
|
|
||||||
|
def fetch_memories(self, observation: str) -> List[Document]:
|
||||||
|
"""Fetch related memories."""
|
||||||
|
return self.memory_retriever.get_relevant_documents(observation)
|
||||||
|
|
||||||
|
def format_memories_detail(self, relevant_memories: List[Document]) -> str:
|
||||||
|
content_strs = set()
|
||||||
|
content = []
|
||||||
|
for mem in relevant_memories:
|
||||||
|
if mem.page_content in content_strs:
|
||||||
|
continue
|
||||||
|
content_strs.add(mem.page_content)
|
||||||
|
created_time = mem.metadata["created_at"].strftime("%B %d, %Y, %I:%M %p")
|
||||||
|
content.append(f"- {created_time}: {mem.page_content.strip()}")
|
||||||
|
return "\n".join([f"{mem}" for mem in content])
|
||||||
|
|
||||||
|
def format_memories_simple(self, relevant_memories: List[Document]) -> str:
|
||||||
|
return "; ".join([f"{mem.page_content}" for mem in relevant_memories])
|
||||||
|
|
||||||
|
def _get_memories_until_limit(self, consumed_tokens: int) -> str:
|
||||||
|
"""Reduce the number of tokens in the documents."""
|
||||||
|
result = []
|
||||||
|
for doc in self.memory_retriever.memory_stream[::-1]:
|
||||||
|
if consumed_tokens >= self.max_tokens_limit:
|
||||||
|
break
|
||||||
|
consumed_tokens += self.llm.get_num_tokens(doc.page_content)
|
||||||
|
if consumed_tokens < self.max_tokens_limit:
|
||||||
|
result.append(doc)
|
||||||
|
return self.format_memories_simple(result)
|
||||||
|
|
||||||
|
@property
|
||||||
|
def memory_variables(self) -> List[str]:
|
||||||
|
"""Input keys this memory class will load dynamically."""
|
||||||
|
return []
|
||||||
|
|
||||||
|
def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
|
||||||
|
"""Return key-value pairs given the text input to the chain."""
|
||||||
|
queries = inputs.get(self.queries_key)
|
||||||
|
if queries is not None:
|
||||||
|
relevant_memories = [
|
||||||
|
mem for query in queries for mem in self.fetch_memories(query)
|
||||||
|
]
|
||||||
|
return {
|
||||||
|
self.relevant_memories_key: self.format_memories_detail(
|
||||||
|
relevant_memories
|
||||||
|
),
|
||||||
|
self.relevant_memories_simple_key: self.format_memories_simple(
|
||||||
|
relevant_memories
|
||||||
|
),
|
||||||
|
}
|
||||||
|
|
||||||
|
most_recent_memories_token = inputs.get(self.most_recent_memories_token_key)
|
||||||
|
if most_recent_memories_token is not None:
|
||||||
|
return {
|
||||||
|
self.most_recent_memories_key: self._get_memories_until_limit(
|
||||||
|
most_recent_memories_token
|
||||||
|
)
|
||||||
|
}
|
||||||
|
return {}
|
||||||
|
|
||||||
|
def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
|
||||||
|
"""Save the context of this model run to memory."""
|
||||||
|
# TODO: fix the save memory key
|
||||||
|
mem = outputs.get(self.add_memory_key)
|
||||||
|
if mem:
|
||||||
|
self.add_memory(mem)
|
||||||
|
|
||||||
|
def clear(self) -> None:
|
||||||
|
"""Clear memory contents."""
|
||||||
|
# TODO
|
Loading…
Reference in New Issue