How can we show all previous threads in streamlit ui

[anuroop18]

I want all my previous chat threads to appear in sidebar in streamlit ui (Like in chatgpt). Because copying thread_id and pasting as url query string is not very useful for me.

Will i have to store each thread_id in a json file once it is created? Or is there any better approach?

[anuroop18]

I was able to achieve this using following code:

import json
from datetime import datetime
from pathlib import Path

# Define and create the data directory
PROJECT_ROOT = Path(__file__).parent.parent
DATA_DIR = PROJECT_ROOT / "data"
DATA_DIR.mkdir(exist_ok=True)
THREAD_HISTORY_FILE = DATA_DIR / "thread_history.json"

def load_thread_history() -> dict:
    try:
        with open(THREAD_HISTORY_FILE, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return {}

def save_thread_history(threads: dict) -> None:
    with open(THREAD_HISTORY_FILE, "w") as f:
        json.dump(threads, f)

def update_thread_access(thread_id: str) -> None:
    threads = load_thread_history()
    threads[thread_id] = datetime.now().isoformat()
    save_thread_history(threads)

Then we can use that function like following:

# Generate new message if the user provided new input
    if user_input := st.chat_input():
        messages.append(ChatMessage(type="human", content=user_input))
        st.chat_message("human").write(user_input)
        # Update thread access when sending a new message
        update_thread_access(st.session_state.thread_id)

And we can display the threads like following:

# Config options
  with st.sidebar:
      st.divider()
      st.subheader("Previous Conversations")
      # Load and sort threads by last access time
      threads = load_thread_history()
      sorted_threads = sorted(threads.items(), key=lambda x: x[1], reverse=True)

      for thread_id, last_accessed in sorted_threads:
          last_accessed_dt = datetime.fromisoformat(last_accessed)
          display_time = last_accessed_dt.strftime("%Y-%m-%d %H:%M")
          # Create clickable link with the current URL base and target="_self"
          thread_url = f"?thread_id={thread_id}"
          st.markdown(f'<a href="{thread_url}" target="_self">Thread: {thread_id[:8]}... ({display_time})</a>', unsafe_allow_html=True)

Is there a better approach??
How do i get nice summary of that thread like in chatgpt??

[anuroop18]

And these threads are not preserved over restarts of server.. how to achieve that?

[JoshuaC215]

Hi Anuroop, nice! Your approach makes sense. For a quick summary, you would want to make a separate call to an LLM asking it to generate a title based on the provided conversation. Here's an example prompt I wrote in a previous project:

https://github.com/streamlit/llm-examples/blob/llm-eval/llm-eval/common_ui.py#L168-L190

Once you have the title, you could add that to the thread dictionary as a new key.

One thing to note - with your approach it will work locally but:

• On a cloud deployment, the JSON file might not be persisted unless you put it on a durable volume. Alternatively you could store it in a database that you provide (this is not possible in Streamlit Cloud, you'd need to set up an external database)
• Since you used a global file, if multiple users are interacting with the app they would all see the same message history. To solve this you would need some kind of user identity (like a browser cookie or login) and then also include that in the conversation history.

The example project I linked above had many of these features although I didn't use a cookie for login. It's a somewhat complex app and I haven't tried to integrate it with agent-service-toolkit. I don't really have capacity to work on that but maybe it will be a good reference for you or anyone else.

You can view the app here: https://llm-eval-demo.streamlit.app/about

[anuroop18]

I’ll review the example project you shared to integrate similar features into my app. I really appreciate your help. Thanks a lot.. 😊

[tyadav7]

I might be late to the discussion, but I wanted to share my thoughts on this.

I had a similar requirement where I needed to retrieve all threads for a particular user at client load. However, I noticed that threads aren’t being persisted anywhere in the code—it looks like they’re embedded inside the agent itself.

I tried a few things to extract possible states from the agent since it stores a checkpointer. While checkpointer.list() returns previous checkpoints, it doesn’t seem very useful for restoring the full state. Instead, I’m more interested in using agent.get_state() to retrieve meaningful states for all existing threads and correctly load the UI state.

I also noticed that Langraph Server has a built-in threading system, where each session or conversation is tied to a thread that can be stored in a database. Implementing something similar here might be the best approach.

For assigning a title to each thread, I’m thinking of making an AI call to generate the title and attaching it to the appropriate thread. The challenge is figuring out the right step in the agent graph to do this—maybe through a conditional run?

Would love to hear thoughts on this approach!

[JoshuaC215]

Yes, that roughly makes sense. Just as another idea, I wonder if you could also do a thin wrapper around the LangGraph checkpointer API which included storing the list of threads and titles in a format you were happy with, and then attach that to the agent instead.

Given the state is already being managed in the agent checkpointer, for an open source implementation I'd definitely look at improving / leveraging that vs setting up a separate store you have to keep in sync.

I haven't gone deep in this area to have a more prescriptive or specific suggestion.