Deepagents JS docs

src/docs.json

@@ -583,6 +583,30 @@
                       }
                     ]
                   },
+                  {
+                    "tab": "Deep Agents",
+                    "pages": [
+                      "oss/javascript/deepagents/overview",
+                      {
+                        "group": "Get started",
+                        "pages": [
+                          "oss/javascript/deepagents/quickstart",
+                          "oss/javascript/deepagents/customization"
+                        ]
+                      },
+                      {
+                        "group": "Core capabilities",
+                        "pages": [
+                          "oss/javascript/deepagents/harness",
+                          "oss/javascript/deepagents/backends",
+                          "oss/javascript/deepagents/subagents",
+                          "oss/javascript/deepagents/human-in-the-loop",
+                          "oss/javascript/deepagents/long-term-memory",
+                          "oss/javascript/deepagents/middleware"
+                        ]
+                      }
+                    ]
+                  },
                   {
                     "tab": "Integrations",
                     "pages": [
@@ -709,7 +733,8 @@
                         "group": "Reference",
                         "pages": [
                           "oss/javascript/reference/langchain-javascript",
-                          "oss/javascript/reference/langgraph-javascript"
+                          "oss/javascript/reference/langgraph-javascript",
+                          "oss/javascript/reference/deepagents-javascript"
                         ]
                       },
                       {

src/oss/deepagents/backends.mdx

@@ -37,6 +37,20 @@ agent = create_deep_agent(
 ```
 :::
 
+:::js
+```typescript
+import { createDeepAgent, StateBackend } from "deepagents";
+
+// By default we provide a StateBackend
+const agent = createDeepAgent();
+
+// Under the hood, it looks like
+const agent2 = createDeepAgent({
+  backend: (rt) => new StateBackend(rt),   // Note that the tools access State through the runtime.state
+});
+```
+:::
+
 **How it works:**
 - Stores files in LangGraph agent state for the current thread.
 - Persists across multiple agent turns on the same thread via checkpoints.
@@ -47,17 +61,28 @@ agent = create_deep_agent(
 
 ### FilesystemBackend (local disk)
 
+:::python
 ```python
 from deepagents.backends import FilesystemBackend
 
 agent = create_deep_agent(
-    backend=FilesystemBackend(root_dir="/Users/nh/Desktop/")
+    backend=FilesystemBackend(root_dir=".", virtual_mode=True)
 )
 ```
+:::
+
+:::js
+```typescript
+import { createDeepAgent, FilesystemBackend } from "deepagents";
+
+const agent = createDeepAgent({
+  backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
+});
+```
+:::
 
 **How it works:**
 - Reads/writes real files under a configurable `root_dir`.
-- Note: `root_dir` must be an absolute path.
 - You can optionally set `virtual_mode=True` to sandbox and normalize paths under `root_dir`.
 - Uses secure path resolution, prevents unsafe symlink traversal when possible, can use ripgrep for fast `grep`.
 
@@ -68,13 +93,30 @@ agent = create_deep_agent(
 
 ### StoreBackend (LangGraph Store)
 
+:::python
 ```python
+from langgraph.store.memory import InMemoryStore
 from deepagents.backends import StoreBackend
 
 agent = create_deep_agent(
-    backend=(lambda rt: StoreBackend(rt))   # Note that the tools access Store through the runtime.store
+    backend=(lambda rt: StoreBackend(rt)),   # Note that the tools access Store through the runtime.store
+    store=InMemoryStore()
 )
 ```
+:::
+
+:::js
+```typescript
+import { createDeepAgent, StoreBackend } from "deepagents";
+import { InMemoryStore } from "@langchain/langgraph";
+
+const store = new InMemoryStore()
+const agent = createDeepAgent({
+  backend: (rt) => new StoreBackend(rt),
+  store
+});
+```
+:::
 
 **How it works:**
 - Stores files in a LangGraph `BaseStore` provided by the runtime, enabling cross‑thread durable storage.
@@ -89,18 +131,37 @@ agent = create_deep_agent(
 :::python
 ```python
 from deepagents import create_deep_agent
-from deepagents.backends import FilesystemBackend
-from deepagents.backends.composite import build_composite_state_backend
+from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
+from langgraph.store.memory import InMemoryStore
 
 composite_backend = lambda rt: CompositeBackend(
-    default=StateBackend(rt)
+    default=StateBackend(rt),
     routes={
         "/memories/": StoreBackend(rt),
-        "/docs/": CustomBackend()
     }
 )
 
-agent = create_deep_agent(backend=composite_backend)
+agent = create_deep_agent(
+    backend=composite_backend,
+    store=InMemoryStore()  # Store passed to create_deep_agent, not backend
+)
+```
+:::
+
+:::js
+```typescript
+import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend } from "deepagents";
+import { InMemoryStore } from "@langchain/langgraph";
+
+const compositeBackend = (rt) => new CompositeBackend(
+  new StateBackend(rt),
+  {
+    "/memories/": new StoreBackend(rt),
+  }
+);
+
+const store = new InMemoryStore()
+const agent = createDeepAgent({ backend: compositeBackend, store });
 ```
 :::
 
@@ -129,19 +190,34 @@ Route parts of the namespace to different backends. Commonly used to persist `/m
 :::python
 ```python
 from deepagents import create_deep_agent
-from deepagents.backends import FilesystemBackend
-from deepagents.backends.composite import build_composite_state_backend
+from deepagents.backends import CompositeBackend, StateBackend, FilesystemBackend
 
 composite_backend = lambda rt: CompositeBackend(
+    default=StateBackend(rt),
     routes={
-        "/memories/": FilesystemBackend(root_dir="/deepagents/myagent"),
+        "/memories/": FilesystemBackend(root_dir="/deepagents/myagent", virtual_mode=True),
     },
 )
 
 agent = create_deep_agent(backend=composite_backend)
 ```
 :::
 
+:::js
+```typescript
+import { createDeepAgent, CompositeBackend, FilesystemBackend, StateBackend } from "deepagents";
+
+const compositeBackend = (rt) => new CompositeBackend(
+  new StateBackend(rt),
+  {
+    "/memories/": new FilesystemBackend({ rootDir: "/deepagents/myagent", virtualMode: true }),
+  },
+);
+
+const agent = createDeepAgent({ backend: compositeBackend });
+```
+:::
+
 Behavior:
 - `/workspace/plan.md` → StateBackend (ephemeral)
 - `/memories/agent.md` → FilesystemBackend under `/deepagents/myagent`

src/oss/deepagents/customization.mdx

@@ -24,7 +24,25 @@ agent = create_deep_agent(
 
 :::js
 ```typescript
-// TODO: Add JS implementation
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+import { createDeepAgent } from "deepagents";
+
+// Using Anthropic
+const agent = createDeepAgent({
+  model: new ChatAnthropic({
+    model: "claude-sonnet-4-20250514",
+    temperature: 0,
+  }),
+});
+
+// Using OpenAI
+const agent2 = createDeepAgent({
+  model: new ChatOpenAI({
+    model: "gpt-5",
+    temperature: 0,
+  }),
+});
 ```
 :::
 
@@ -51,7 +69,13 @@ agent = create_deep_agent(
 
 :::js
 ```typescript
-// TODO: Add JS implementation
+import { createDeepAgent } from "deepagents";
+
+const researchInstructions = `You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.`;
+
+const agent = createDeepAgent({
+  systemPrompt: researchInstructions,
+});
 ```
 :::
 
@@ -90,7 +114,49 @@ agent = create_deep_agent(
 
 :::js
 ```typescript
-// TODO: Add JS implementation
+import { tool } from "langchain";
+import { TavilySearch } from "@langchain/tavily";
+import { createDeepAgent } from "deepagents";
+import { z } from "zod";
+
+const internetSearch = tool(
+  async ({
+    query,
+    maxResults = 5,
+    topic = "general",
+    includeRawContent = false,
+  }: {
+    query: string;
+    maxResults?: number;
+    topic?: "general" | "news" | "finance";
+    includeRawContent?: boolean;
+  }) => {
+    const tavilySearch = new TavilySearch({
+      maxResults,
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      includeRawContent,
+      topic,
+    });
+    return await tavilySearch._call({ query });
+  },
+  {
+    name: "internet_search",
+    description: "Run a web search",
+    schema: z.object({
+      query: z.string().describe("The search query"),
+      maxResults: z.number().optional().default(5),
+      topic: z
+        .enum(["general", "news", "finance"])
+        .optional()
+        .default("general"),
+      includeRawContent: z.boolean().optional().default(false),
+    }),
+  },
+);
+
+const agent = createDeepAgent({
+  tools: [internetSearch],
+});
 ```
 :::