docs/build/snippets/python/code-samples/long-term-memory-write-tool-postgres-js.mdx

<CodeGroup>
    ```ts Google
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "google-genai:gemini-3.6-flash",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts OpenAI
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "openai:gpt-5.5",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts Anthropic
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "anthropic:claude-sonnet-4-6",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts OpenRouter
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "openrouter:openrouter:z-ai/glm-5.2",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts Fireworks
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "fireworks:accounts/fireworks/models/glm-5p2",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts Baseten
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "baseten:zai-org/GLM-5.2",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```

    ```ts Ollama
    import * as z from "zod";
    import { tool, createAgent, type ToolRuntime } from "langchain";
    import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
    
    const DB_URI =
      process.env.POSTGRES_URI ??
      "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
    const store = PostgresStore.fromConnString(DB_URI);
    await store.setup();
    
    const contextSchema = z.object({ userId: z.string() });
    
    const UserInfo = z.object({ name: z.string() });
    
    const saveUserInfo = tool(
      async (
        userInfo: z.infer<typeof UserInfo>,
        runtime: ToolRuntime<unknown, z.infer<typeof contextSchema>>,
      ) => {
        const userId = runtime.context.userId;
        if (!userId) throw new Error("userId is required");
        await runtime.store.put(["users"], userId, userInfo);
        return "Successfully saved user info.";
      },
      { name: "save_user_info", description: "Save user info", schema: UserInfo },
    );
    
    const agent = createAgent({
      model: "ollama:north-mini-code-1.0",
      tools: [saveUserInfo],
      contextSchema,
      store,
    });
    
    await agent.invoke(
      { messages: [{ role: "user", content: "My name is John Smith" }] },
      { context: { userId: "user_123" } },
    );
    
    const result = await store.get(["users"], "user_123");
    console.log(result?.value);
    ```
</CodeGroup>