Forem: Sandip Mandal

Effortless PostgreSQL Environment in Docker For Windows

Sandip Mandal — Tue, 04 Nov 2025 20:45:28 +0000

Introduction
PostgreSQL is a powerful, open-source object-relational database system. It is a highly scalable, SQL-compliant database management system that is used to handle large workloads. PostgreSQL is a popular choice for many developers and organizations due to its robust features, extensibility, and reliability.

Installing PostgreSQL directly on your local machine can be a difficult and also take multiple steps, configuration issues, and potential conflicts with other software. This process is especially cumbersome on Windows. Fortunately, Docker provides a much simpler, faster, and more portable solution. Let’s go through how to set up and run PostgreSQL inside a Docker container.

Before Docker

You must install PostgreSQL locally, configure paths, users, and ports manually.
Resetting the database means manually dropping tables or reinstalling.
Different projects may need different PostgreSQL versions — hard to manage on one system.
Config files, logs, and data clutter your OS. Uninstalling doesn’t clean everything.
Every team member must install and configure PostgreSQL the same way.

After Docker

One docker-compose up and you have a running PostgreSQL instance.
Just docker down and docker up to reset everything.
You can switch PostgreSQL versions by changing one line in your config.
Everything runs inside a container — no system pollution.
Easily link PostgreSQL with backend services (Node.js, Django, etc.) in one Compose file.

Prerequisites
Before you begin, you will need to have the following prerequisites:

A system running Windows
Docker installed on your system
Basic knowledge of using the command line

Installing Docker

If you doesn't have Docker installed on your Windows, you can download and install it from the official Docker website. Follow the instructions provided on the website step by step to install Docker on your Windows.

Once the docker is installed, you can verify the installation by running:

docker --version

This command will display the version of Docker installed on your system.

To create a PostgreSQL environment in Docker you can choose between two approaches GUI-based or terminal-based. Let's start with GUI-based method first.

Create Folder

Create a new folder to store your PostgreSQL data. This folder will be used to store the data files for your PostgreSQL instance. Usually keep this directory in your project folder so that it is easy to manage.

Docker Compose File

Create a new file named compose.yml in the same folder. This file will contain the configuration for your PostgreSQL container.

Insert the following content into the compose.ymlfile:

services:
  db:
    image: postgres:alpine
    container_name: postgres
    restart: always
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - ${DB_PORT}:5432  # Ensure no other service is using this port
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${DB_NAME} -U $${DB_USER}"]
      interval: 10s
      timeout: 30s
      retries: 5
    volumes:
      - ./data/db:/var/lib/postgresql/data

  pgadmin:
    image: dpage/pgadmin4
    container_name: pgadmin
    restart: always
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_EMAIL}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_PASSWORD}
    ports:
      - 8080:80  # Access pgAdmin at http://localhost:8080
    depends_on:
      - db

This configuration defines two services: db and pgAdmin.
The db service runs a PostgreSQL instance using the official Docker image, with data stored in ./data/db. It exposes port 5432 and uses environment variables to set the database name, user, and password.

The pgAdmin service uses the dpage/pgadmin4 image to provide a web-based PostgreSQL management interface. It maps port 8080 on the host to port 80 in the container, letting you access pgAdmin at http://localhost:8080 using the credentials defined in the environment file.

If you want a fast, portable, and minimal tool to manage multiple databases — especially in Docker or lightweight environments. Can use these code

adminer:
    image: adminer
    container_name: adminer
    restart: always
    ports:
      - 8080:8080

replace pgadmin code with adminer code .

Environment Variables
To configure the database name, username, and password, create a .env file in the same directory as your docker-compose.yml file and add the following content:

DB_NAME=test-db
DB_USER=testuser
DB_PASSWORD=userpass
DB_PORT=5432
# Use PGADMIN_EMAIL and PGADMIN_PASSWORD only if you’re using pgAdmin. 
PGADMIN_EMAIL=admin@example.com
PGADMIN_PASSWORD=adminpass

Replace the values with your preferred database name, username, and credentials.

Start the Container
Run the following command to start PostgreSQL and the chosen management tool(s):

docker compose up -d

This command will pull the necessary Docker images and start PostgreSQL, pgAdmin, and/or Adminer in the background. You can verify that the containers are running by executing the following command:

docker ps

You should see postgres, pgadmin, and/or adminer listed in the output.

Access the Web Interfaces

You can choose between pgAdmin or Adminer, depending on your preference: by opening a web browser and navigating to http://localhost:8080. In the login page, enter the database name, username, and password that you specified in the compose.yml file. You should now be able to interact with your PostgreSQL database through the Adminer or pgAdmin web interface.

Connect with PostgreSQL
To connect with database url, you can use the following url:

postgresql://testuser:userpass@localhost:5432/test-db

That’s it! You’ve successfully set up PostgreSQL using Docker on your system.

Let's start with terminal-based method

Step 1: Download the PostgreSQL Image
Download the PostgreSQL image from Docker Hub at docker Hub

docker pull postgres

Step 2: Create a PostgreSQL Container
Start creating a container with the following command:

docker run --name test-db -e POSTGRES_PASSWORD=userpass -d -p 5432:5432 postgres

“test-db” is the name of the container (you can choose a different name if you prefer).
“userpass” is the password you want to set for the “postgres” user in PostgreSQL.
The “-d” option runs the container in the background.
The “-p 5432:5432” option maps port 5432 from the container to port 5432 on the host, allowing you to connect to PostgreSQL from the host.

*Step 3: Download pgAdmin *
Let's download the pgAdmin image from Docker Hub

docker pull dpage/pgadmin4

Afterward, you need to create a container for running pgAdmin using the code:

docker run --name testuser -p 15432:80 -e "PGADMIN_DEFAULT_EMAIL=my_email@test.com" -e "PGADMIN_DEFAULT_PASSWORD=userpass" -d dpage/pgadmin4

“testuser” is the name of the container being created.
The “-p 15432:80” option maps port 15432, which is used for communication with pgAdmin, to port 80.
“PGADMIN_DEFAULT_EMAIL” will be the login you use to access pgAdmin.
“PGADMIN_DEFAULT_PASSWORD” will be the password you use to access pgAdmin.

You can access pgAdmin at https://localhost:15432, and you will see the pgAdmin interface.

Summary
That’s it! You’ve successfully set up PostgreSQL using Docker — through both GUI (Docker Compose) and terminal-based methods.
With this setup, you can easily manage databases, switch PostgreSQL versions, and connect your applications — all without cluttering your local system.

Introducing Google Vertex AI Agent Engine Memory Bank: Making AI Agents Remember

Sandip Mandal — Tue, 22 Jul 2025 19:53:32 +0000

Ever wish your AI agent could actually remember things about you, like a real assistant? Google just released Memory Bank in Vertex AI Agent Engine—a powerful new solution for giving your AI agents real long-term memory! This isn’t just another GCP feature; it’s grounded in brand-new research on how to make memory work well for AI.

In this blog, I’ll explain why long-term memory is such a game-changer for AI agents, what makes Memory Bank special, and how you can start using it in your projects.

Why Do AI Agents Need Long-Term Memory?
Most current AI agents—like chatbots powered by large language models—are stateless. That means every time you start a conversation, it’s a blank slate; your agent doesn’t know anything you shared in previous sessions unless you tell it all over again.

For example, imagine asking your agent, “Can you help me plan a trip to Italy?” It can give some answers. But if you come back tomorrow and want to continue planning, it has no memory of that earlier conversation. This lack of continuity makes it hard to build helpful, personalized agents.

Some big AI platforms (like ChatGPT or Gemini) seem like they remember you—they personalize your experience by managing long-term memory in the background. But until now, most developers had to build complex workarounds to achieve this.

Typical (and Painful) Old Approaches
Before Memory Bank, there were two common but imperfect ways to mimic memory:

1. Prompt Stuffing:
You’d cram the entire conversation history each time into the prompt. This gets expensive, slow, and confusing as conversations grow.
2. Similarity Search or RAG:
Here, you save all conversation history, and when needed, retrieve “chunks” of relevant information. This is better, but the chunks are often disconnected facts that don’t always make sense together in context.

Problems with these methods:

Hard to maintain.
Inefficient and expensive.
Often lose the true context you want the agent to remember.

What’s New With Memory Bank?
Google’s new Memory Bank was designed to solve exactly these problems. It combines new research and practical tools so your agent can:

Truly Personalize: Remember and recall user preferences, past actions, and interactions.
Maintain Context Continuity: Know what details to remember and what can be skipped.
Optimize Retrieval: Use reinforcement learning to highlight info that’s actually useful, not just what happens to match a keyword.

Key Innovations
Memory Bank introduces two core techniques from recent research:

Prospective Reflection The agent summarizes scattered conversation fragments into cohesive, useful memories—reducing redundancy and improving recall.
Retrospective Reflection The system continually learns what “memories” are most helpful based on user interactions—refining and prioritizing important info over time.

With these, your agent not only stores user facts like allergies or travel destinations, but also understands which details to bring up at the right time (and which to leave out)

How Can You Use Memory Bank?
Getting started is straightforward:

In Vertex AI Agent Engine:
When you deploy an agent, set up a session in Google Cloud Platform’s Agent Engine. Memory Bank is built in—you just enable it!
Via REST API:
There’s a REST API for Memory Bank. Whatever framework you use (LangGraph, LlamaIndex, Google’s ADK, etc.), you can call the API to update, save, or retrieve memory.
With Google ADK:
Google’s new open-source Agent Development Kit (ADK) integrates Memory Bank natively—no extra setup needed! All memory management is handled automatically while you build with ADK.

Real-World Example
Let’s say you tell your agent today that you have a gluten allergy and love aisle seats on flights. Next month, when you ask for dinner suggestions or book a trip, the agent recalls your allergy and seat preference without reminders. This seamless recall brings the magic of a personalized AI experience—with no hacks or complex prompts.

Summary
With Memory Bank, Google just made powerful, long-term AI agent memory accessible to everyone. It’s efficient, smart, and easy to use—no more prompt-gymnastics or brittle hacks needed. If you want to build agents that remember users and act more like helpful assistants, it’s time to give Memory Bank a try.

You can find more details and try out the sample notebook from the official Vertex AI Memory Bank documentation.
Let me know in the comments how you plan to use Memory Bank, or what features you want to see next!