How to write sting to session memory via python api

[LeeMoofon0222]

Hi,
I am currently using Langflow and would like to know how to write sting to session memory via the Python API.
I have searched for similar discussions and tried the following code to load a session:

def post_explaintion(message, sessionId):

    # Create a ZepClient instance
    zep_client = ZepClient("http://localhost:8000", api_key="optional_api_key")

    # Create a ZepChatMessageHistory instance
    memory = ZepChatMessageHistory(session_id=sessionId, zep_client=zep_client)

    # Create an instance of ZepMessageWriterComponent and add the message
    zep_writer = ZepMessageWriterComponent()
    zep_writer.add_message(
        sender="User",
        sender_name="Explaintion",
        text=message,
        session_id=sessionId,
        memory=memory
    )

The error I got:

APIError: Failed to connect to Zep server. Please check that: - the status of the service - your internet connection is working - the API URL is correct (not required for Zep Cloud) - No other process is using the same port (not required for Zep Cloud) : None

[dosubot[bot]]

To resolve the APIError and successfully write a string to session memory using the Python API in Langflow, you need to ensure that the zep-python package is installed and correctly configure the ZepClient and ZepMessageWriterComponent. Here is an example of how you can do this:

1. Ensure you have the zep-python package installed:

   pip install zep-python

2. Use the ZepClient and ZepMessageWriterComponent to add a message:

   from zep_python import ZepClient
   from zep_python.langchain import ZepChatMessageHistory
   from your_module import ZepMessageWriterComponent  # Adjust the import according to your module structure
   
   def post_explaintion(message, sessionId):
       # Create a ZepClient instance
       zep_client = ZepClient(api_url="http://localhost:8000", api_key="optional_api_key")
   
       # Create a ZepChatMessageHistory instance
       memory = ZepChatMessageHistory(session_id=sessionId, zep_client=zep_client)
   
       # Create an instance of ZepMessageWriterComponent and add the message
       zep_writer = ZepMessageWriterComponent()
       zep_writer.add_message(
           sender="User",
           sender_name="Explaintion",
           text=message,
           session_id=sessionId,
           memory=memory
       )

Make sure to replace "http://localhost:8000" and "optional_api_key" with your actual Zep server URL and API key if needed. This code snippet demonstrates how to configure and use the ZepClient and ZepMessageWriterComponent to add a message to the session memory ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[dosubot[bot]]

You should define your "session id", "sender", "sender_name", and "message" as parameters in the store_message, build_with_record, and build_no_record methods of the ChatComponent class. Here is how they are defined in the code:

def store_message(
    self,
    message: Union[str, Text, Record],
    session_id: Optional[str] = None,
    sender: Optional[str] = None,
    sender_name: Optional[str] = None,
) -> list[Record]:
    # Method implementation

def build_with_record(
    self,
    sender: Optional[str] = "User",
    sender_name: Optional[str] = "User",
    input_value: Optional[Union[str, Record]] = None,
    session_id: Optional[str] = None,
    return_record: Optional[bool] = False,
    record_template: str = "Text: {text}\nData: {data}",
) -> Union[Text, Record]:
    # Method implementation

def build_no_record(
    self,
    sender: Optional[str] = "User",
    sender_name: Optional[str] = "User",
    input_value: Optional[str] = None,
    session_id: Optional[str] = None,
    return_record: Optional[bool] = False,
    record_template: str = "Text: {text}\nData: {data}",
) -> Union[Text, Record]:
    # Method implementation

In these methods, session_id, sender, sender_name, and message are defined as parameters.

Additionally, in the ChatOutput and ChatInput classes, these parameters are also defined and used:

class ChatOutput(ChatComponent):
    display_name = "Chat Output"
    description = "Display a chat message in the Interaction Panel."
    icon = "ChatOutput"

    def build(
        self,
        sender: Optional[str] = "Machine",
        sender_name: Optional[str] = "AI",
        input_value: Optional[str] = None,
        session_id: Optional[str] = None,
        return_record: Optional[bool] = False,
        record_template: Optional[str] = "{text}",
    ) -> Union[Text, Record]:
        return super().build_with_record(
            sender=sender,
            sender_name=sender_name,
            input_value=input_value,
            session_id=session_id,
            return_record=return_record,
            record_template=record_template or "",
        )

class ChatInput(ChatComponent):
    display_name = "Chat Input"
    description = "Get chat inputs from the Interaction Panel."
    icon = "ChatInput"

    def build_config(self):
        build_config = super().build_config()
        build_config["input_value"] = {
            "input_types": [],
            "display_name": "Message",
            "multiline": True,
        }

        return build_config

    def build(
        self,
        sender: Optional[str] = "User",
        sender_name: Optional[str] = "User",
        input_value: Optional[str] = None,
        session_id: Optional[str] = None,
        return_record: Optional[bool] = False,
    ) -> Union[Text, Record]:
        return super().build_no_record(
            sender=sender,
            sender_name=sender_name,
            input_value=input_value,
            session_id=session_id,
            return_record=return_record,
        )

In these classes, session_id, sender, sender_name, and message (referred to as input_value) are defined as parameters and used in the build methods.

Furthermore, the build_config method in the ChatInput class defines the message parameter with additional configuration details:

def build_config(self):
    build_config = super().build_config()
    build_config["input_value"] = {
        "input_types": [],
        "display_name": "Message",
        "multiline": True,
    }

    return build_config

This configuration specifies that the message parameter should be displayed as a multiline input field in the UI.

The ChatOutput and ChatInput classes also include detailed configurations for these parameters, as shown in the JSON configuration:

{
  "template": {
    "input_value": {
      "type": "str",
      "required": false,
      "placeholder": "",
      "list": false,
      "show": true,
      "multiline": true,
      "name": "input_value",
      "display_name": "Message",
      "input_types": ["Text"]
    },
    "sender": {
      "type": "str",
      "required": false,
      "placeholder": "",
      "list": true,
      "show": true,
      "value": "Machine",
      "options": ["Machine", "User"],
      "name": "sender",
      "display_name": "Sender Type",
      "input_types": ["Text"]
    },
    "sender_name": {
      "type": "str",
      "required": false,
      "placeholder": "",
      "list": false,
      "show": true,
      "value": "AI",
      "name": "sender_name",
      "display_name": "Sender Name",
      "input_types": ["Text"]
    },
    "session_id": {
      "type": "str",
      "required": false,
      "placeholder": "",
      "list": false,
      "show": true,
      "name": "session_id",
      "display_name": "Session ID",
      "input_types": ["Text"]
    }
  }
}

This JSON configuration further clarifies how these parameters are defined and used within the ChatOutput and ChatInput components ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[LeeMoofon0222]

@dosu

from` langchain.cache import InMemoryCache
from langflow.services.session.factory import SessionServiceFactory
import asyncio

async def post_explaintion(message, session_id):
    # Add the message to the session memory
    await session_service.update_session(session_id, {
        "sender": "User",
        "sender_name": "Explanation",
        "text": message,
        "metadata": {}
    })
    
# Instantiate the cache service
cache = InMemoryCache()

# Instantiate the session service factory
session_service_factory = SessionServiceFactory()

# Create the session service with the cache service
session_service = session_service_factory.create(cache)

asyncio.run(post_explaintion(feature_explaintion, sessionID))

AttributeError: 'InMemoryCache' object has no attribute 'set'

[dosubot[bot]]

To resolve the AttributeError: 'InMemoryCache' object has no attribute 'set' and correctly write a string to session memory using Langflow's built-in components, you need to use the ThreadingInMemoryCache class instead of InMemoryCache. Here is the updated code:

from langflow.services.cache.service import ThreadingInMemoryCache
from langflow.services.session.factory import SessionServiceFactory
import asyncio

async def post_explaintion(message, session_id):
    # Add the message to the session memory
    await session_service.update_session(session_id, {
        "sender": "User",
        "sender_name": "Explanation",
        "text": message,
        "metadata": {}
    })

# Instantiate the cache service
cache = ThreadingInMemoryCache()

# Instantiate the session service factory
session_service_factory = SessionServiceFactory()

# Create the session service with the cache service
session_service = session_service_factory.create(cache)

# Define your message and session ID
feature_explaintion = "Your message here"
sessionID = "your_session_id"

# Run the function to post the explanation
asyncio.run(post_explaintion(feature_explaintion, sessionID))

This code snippet demonstrates how to use ThreadingInMemoryCache and SessionServiceFactory to write a string to session memory correctly ^[1][2].

To continue talking to Dosu, mention @dosu.

[LeeMoofon0222]

@dosu
It's not work at all

[dosubot[bot]]

To help you further, let's ensure we have the correct setup and steps to write a string to session memory using Langflow's built-in components. Here is a complete example:

1. Ensure you have the necessary imports:

from langflow.services.cache.service import ThreadingInMemoryCache
from langflow.services.session.factory import SessionServiceFactory
import asyncio

2. Define the function to post the explanation:

async def post_explaintion(message, session_id):
    # Add the message to the session memory
    await session_service.update_session(session_id, {
        "sender": "User",
        "sender_name": "Explanation",
        "text": message,
        "metadata": {}
    })

3. Instantiate the cache service and session service factory:

# Instantiate the cache service
cache = ThreadingInMemoryCache()

# Instantiate the session service factory
session_service_factory = SessionServiceFactory()

# Create the session service with the cache service
session_service = session_service_factory.create(cache)

4. Define your message and session ID, and run the function:

# Define your message and session ID
feature_explaintion = "Your message here"
sessionID = "your_session_id"

# Run the function to post the explanation
asyncio.run(post_explaintion(feature_explaintion, sessionID))

Here is the complete code snippet:

from langflow.services.cache.service import ThreadingInMemoryCache
from langflow.services.session.factory import SessionServiceFactory
import asyncio

async def post_explaintion(message, session_id):
    # Add the message to the session memory
    await session_service.update_session(session_id, {
        "sender": "User",
        "sender_name": "Explanation",
        "text": message,
        "metadata": {}
    })

# Instantiate the cache service
cache = ThreadingInMemoryCache()

# Instantiate the session service factory
session_service_factory = SessionServiceFactory()

# Create the session service with the cache service
session_service = session_service_factory.create(cache)

# Define your message and session ID
feature_explaintion = "Your message here"
sessionID = "your_session_id"

# Run the function to post the explanation
asyncio.run(post_explaintion(feature_explaintion, sessionID))

This should correctly write a string to session memory using Langflow's built-in components. If you encounter any specific errors, please provide the error message so I can assist you further.

To continue talking to Dosu, mention @dosu.