[Setup]: Connection to LiteLLM as MCP Proxy, then Open-WebUI using that MCP, retain operation stuck in Pending

[gerbpaul]

What's Going Wrong?

My setup includes:

• Hindsight connected with LiteLLM as the model provider - Works Well
• MCP enabled in Hindsight - Works Well
• MCP server connection to Hindsight from LiteLLM - Works Well
• Use Open-WebUI to connect to the Hindsight MCP I setup in LiteLLM - Works Well

I try to "test" the Hindsight memory solution and it works, the retain operation grabs the memory, and begins to process it.

The memory processing seems to be stuck at "Pending". So when Open-WebUI checks the memory using the recall operation after retaining it, it can't, because it apparently hasn't completed processing. Problem is, it just stays in pending, it never finishes.

Steps Taken

I have tried this through the LiteLLM playground and MCP testing capability, same behavior as what I see in Open-WebUI.

Installation Method

Docker

Operating System

Windows 11

Python Version

3.11.9

Debug Info

I have debug logging on. I am not really seeing anything that resembles an exception. I do see this....

2026-04-26 18:46:09,614 - INFO - hindsight_api.worker.poller - [PENDING_BREAKDOWN] batch_retain: total=3 claimable=0 payload_null=3 retry_blocked=0 assigned=0 | retain: total=3 claimable=3 payload_null=0 retry_blocked=0 assigned=0

2026-04-26 18:46:39,885 - INFO - hindsight_api.worker.poller - [WORKER_STATS] worker=4f2f18748deb slots=0/10 (consolidation=0/2) | available=8 (consolidation=2) | global: pending=6 (schemas: default) | others: none | pool: size=1 limits=5-100 idle=1 in_use=0 free_holders=100 pending_acquires=0 | proc: rss_mb=890 | my_active: none

2026-04-26 18:46:39,885 - INFO - hindsight_api.worker.poller - [PENDING_BREAKDOWN] batch_retain: total=3 claimable=0 payload_null=3 retry_blocked=0 assigned=0 | retain: total=3 claimable=3 payload_null=0 retry_blocked=0 assigned=0

2026-04-26 18:47:10,316 - INFO - hindsight_api.worker.poller - [WORKER_STATS] worker=4f2f18748deb slots=0/10 (consolidation=0/2) | available=8 (consolidation=2) | global: pending=6 (schemas: default) | others: none | pool: size=1 limits=5-100 idle=1 in_use=0 free_holders=100 pending_acquires=0 | proc: rss_mb=890 | my_active: none

What I've Already Tried

I blew everything away and tried again. Got the same behavior.

One thing to note is that I had all sorts of trouble getting my docker compose process to work. Had to leverage AI to help me work through it.

Started with issues during the build proccess. I believe most of the issues were around not being able to get "pg_textsearch" installed.

Ultimately had to change up a few things in dockerfile and docker-compose to get it to complete the build process. Then there were issues because the schema wasn't working appropriately. Please pardon my ignorance if I sound elementary with this, I am not a developer, so some of this is way over my head.

I eventually had to delete the pg_textsearch extension and recreate it, then do something to define "schemas with pending work".

I am not sure if this has something to do with it or not, but I do see the word "pending" in there.

FIgured I would paste my dockerfile, docker-compose, and then the scripts I had to run to "fix" "schemas with pending work", etc.

docker-compose.yml....

name: hindsight
services:
  db:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: hindsight-db-timescale
    restart: always
    command: ["postgres", "-c", "shared_preload_libraries=pg_textsearch"]
    ports:
      - "5438:5432"
    environment:
      # Using standard postgres defaults
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: postgres
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - hindsight-net
    healthcheck:
      # Updated to check against the default postgres db
      test: ["CMD-SHELL", "pg_isready -U postgres -d postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  timescale-init:
    build:
      context: .
      dockerfile: Dockerfile
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DB_HOST=hindsight-db-timescale
      - DB_NAME=postgres
      - DB_USER=postgres
      - PGPASSWORD=postgres
    command: >
      sh -c "
      psql -h $$DB_HOST -U postgres -d postgres -c 'CREATE EXTENSION IF NOT EXISTS pg_textsearch CASCADE;'
      "
    restart: "no"
    networks:
      - hindsight-net

  hindsight:
    image: ghcr.io/vectorize-io/hindsight:${HINDSIGHT_VERSION:-latest}
    container_name: hindsight-app-timescale
    ports:
      - "8999:8888"
      - "9999:9999"
    environment:
      # LLM Configuration
      HINDSIGHT_API_LLM_PROVIDER: openai
      HINDSIGHT_API_LLM_API_KEY: # redacting
      HINDSIGHT_API_LLM_MODEL: litellm/gemma-3-4b-it
      HINDSIGHT_API_LLM_BASE_URL: http://192.168.68.78:4000/v1
      ENABLE_OPENAI_COMPATIBILITY: "true"
      HINDSIGHT_API_LOG_LEVEL: DEBUG
      HINDSIGHT_API_MCP_ENABLED: true
      

      # Database Configuration - Updated to use default postgres:postgres@db:5432/postgres
      HINDSIGHT_API_DATABASE_URL: postgresql://postgres:postgres@db:5432/postgres

      HINDSIGHT_API_VECTOR_EXTENSION: pgvectorscale
      HINDSIGHT_API_TEXT_SEARCH_EXTENSION: pg_textsearch

    depends_on:
      db:
        condition: service_healthy
      timescale-init:
        condition: service_completed_successfully
    networks:
      - hindsight-net

networks:
  hindsight-net:
    driver: bridge

volumes:
  pg_data:

dockerfile

# PostgreSQL with pgvector, pgvectorscale, and pg_textsearch extensions
# All three extensions from Timescale/pgvector for high-performance vector and text search
# Note: Requires PostgreSQL 16+
FROM postgres:17

# Install build dependencies and Rust toolchain
RUN apt-get update && apt-get install -y \
    build-essential \
    git \
    postgresql-server-dev-17 \
    libpq-dev \
    cmake \
    curl \
    pkg-config \
    libssl-dev \
    && rm -rf /var/lib/apt/lists/*

# Install Rust toolchain (required for pgvectorscale)
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
ENV PATH="/root/.cargo/bin:${PATH}"

# Install pgvector (required by pgvectorscale)
RUN cd /tmp && \
    git clone --branch v0.8.0 https://github.com/pgvector/pgvector.git && \
    cd pgvector && \
    make && \
    make install && \
    rm -rf /tmp/pgvector

# Add this line before the build step
ENV RUSTFLAGS="-C target-feature=+avx2,+fma"

# Install cargo-pgrx (PostgreSQL extension framework for Rust)
RUN cargo install cargo-pgrx --version 0.12.5 --locked && \
    cargo pgrx init --pg17 /usr/bin/pg_config

# Install pgvectorscale (DiskANN index support)
RUN cd /tmp && \
    git clone --branch 0.5.1 https://github.com/timescale/pgvectorscale.git && \
    cd pgvectorscale/pgvectorscale && \
    cargo pgrx install --release && \
    rm -rf /tmp/pgvectorscale

# Install build dependencies, clone, and compile
RUN apt-get update && apt-get install -y \
    build-essential \
    git \
    postgresql-server-dev-17 \
    && git clone https://github.com/timescale/pg_textsearch.git \
    && cd pg_textsearch \
    && git checkout v1.1.0 \
    && make \
    && make install \
    && cd .. && rm -rf pg_textsearch \
    && apt-get remove -y build-essential git postgresql-server-dev-17 && apt-get autoremove -y

# Install pg_textsearch (BM25 text search)
#RUN cd /tmp && \
#    git clone https://github.com/timescale/pg_textsearch.git && \
#    cd pg_textsearch && \
#    make && \
#    make install && \
#    rm -rf /tmp/pg_textsearch

# Clean up build dependencies (keep runtime dependencies)
RUN apt-get purge -y --auto-remove git cmake curl && \
    rm -rf /root/.cargo/registry /root/.cargo/git

# Ensure extensions are preloaded (pg_textsearch requires preloading)
RUN echo "shared_preload_libraries = 'pg_textsearch'" >> /usr/share/postgresql/postgresql.conf.sample

Scripts

docker exec -it hindsight-db-timescale psql -U postgres -d postgres -c "
CREATE OR REPLACE FUNCTION public.schemas_with_pending_work()
RETURNS TABLE (schema_name name) 
LANGUAGE sql
AS \$$
  SELECT n.nspname 
  FROM pg_namespace n 
  WHERE n.nspname = 'public';
\$$;"

docker exec -it hindsight-db-timescale psql -U postgres -d postgres -c "\df schemas_with_pending_work"

[gerbpaul]

Oh, I also likely have some data from Langfuse traces that could be helpful, if someone gets interested in this one. I haven't dug into that yet, but I figured I would mention it since I do have some level of observability setup here.

[gerbpaul]

What I see in the hindsight logs, with Debug logging enabled......

2026-04-26 22:49:26,559 - INFO - hindsight_api.worker.poller - [PENDING_BREAKDOWN] batch_retain: total=3 claimable=0 payload_null=3 retry_blocked=0 assigned=0 | retain: total=3 claimable=3 payload_null=0 retry_blocked=0 assigned=0

2026-04-26 22:49:56,659 - INFO - hindsight_api.worker.poller - [WORKER_STATS] worker=4f2f18748deb slots=0/10 (consolidation=0/2) | available=8 (consolidation=2) | global: pending=6 (schemas: default) | others: none | pool: size=6 limits=5-100 idle=6 in_use=0 free_holders=100 pending_acquires=0 | proc: rss_mb=890 | my_active: none

[nicoloboschi]

hey sorry for being late to this

did you figure it out?