docs/build/snippets/python/code-samples/customization-memory-store-js.mdx

<CodeGroup>
    ```ts Google
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "google-genai:gemini-3.6-flash",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts OpenAI
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "openai:gpt-5.5",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts Anthropic
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "anthropic:claude-sonnet-4-6",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts OpenRouter
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "openrouter:openrouter:z-ai/glm-5.2",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts Fireworks
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "fireworks:accounts/fireworks/models/glm-5p2",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts Baseten
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "baseten:zai-org/GLM-5.2",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```

    ```ts Ollama
    import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
    import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
    
    const AGENTS_MD_URL =
      "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
    
    async function fetchText(url: string): Promise<string> {
      const res = await fetch(url);
      if (!res.ok) {
        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
      }
      return await res.text();
    }
    
    const agentsMd = await fetchText(AGENTS_MD_URL);
    
    function createFileData(content: string): FileData {
      const now = new Date().toISOString();
      return {
        content,
        mimeType: "text/plain",
        created_at: now,
        modified_at: now,
      };
    }
    
    const store = new InMemoryStore();
    const fileData = createFileData(agentsMd);
    await store.put(["filesystem"], "/AGENTS.md", fileData);
    
    const checkpointer = new MemorySaver();
    
    const agent = await createDeepAgent({
      model: "ollama:north-mini-code-1.0",
      backend: new StoreBackend({
        namespace: () => ["filesystem"],
      }),
      store: store,
      checkpointer: checkpointer,
      memory: ["/AGENTS.md"],
    });
    
    const result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content: "Please tell me what's in your memory files.",
          },
        ],
      },
      { configurable: { thread_id: "12345" } },
    );
    ```
</CodeGroup>