> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chatgrid.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Turn Meeting Notes into Searchable Knowledge

> Extract decisions and action items from meetings, build a searchable knowledge base. 8 minutes.

## What you'll build

A meeting knowledge board that turns raw transcripts into structured, searchable artifacts so decisions never get lost.

* Add meeting transcripts as notepad nodes
* Vectorize for semantic search
* Ask AI to extract decisions, action items, and risks
* Create structured sticky notes linked to source meetings
* Build a weekly digest across multiple meetings

## Prerequisites

* ChatGrid API key ([get one here](/authentication))
* Node.js 18+ or Python 3.10+
* Meeting transcripts (from Otter.ai, Fireflies, Google Meet, or manual notes)

## Step 1: Create a meetings board

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.chatgrid.ai/v1/boards \
    -H "Authorization: Bearer cgk_live_..." \
    -H "Content-Type: application/json" \
    -d '{"name": "Engineering Meetings — March 2026"}'
  ```

  ```typescript Node.js theme={null}
  const res = await fetch("https://api.chatgrid.ai/v1/boards", {
    method: "POST",
    headers: { Authorization: "Bearer cgk_live_...", "Content-Type": "application/json" },
    body: JSON.stringify({ name: "Engineering Meetings — March 2026" }),
  });
  const { data: board } = await res.json();
  const boardId = board.id;
  ```

  ```python Python theme={null}
  import requests
  API_KEY = "cgk_live_..."
  BASE = "https://api.chatgrid.ai/v1"
  headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
  res = requests.post(f"{BASE}/boards", headers=headers, json={"name": "Engineering Meetings — March 2026"})
  board_id = res.json()["data"]["id"]
  ```
</CodeGroup>

## Step 2: Add a meeting transcript

Create a notepad node with the full transcript text.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/nodes \
    -H "Authorization: Bearer cgk_live_..." \
    -H "Content-Type: application/json" \
    -d '{
      "type": "document",
      "position": {"x": 0, "y": 0},
      "data": {
        "label": "Sprint Planning — March 17",
        "content": "Attendees: Sarah, James, Priya\n\nSarah: We need to decide on the caching layer. Redis vs Valkey.\nJames: Redis has better docs but Valkey is OSS and compatible. I vote Valkey.\nPriya: Agreed. Let'\''s set a deadline — end of sprint.\n\nDecision: Use Valkey for caching. Migration deadline: March 28.\n\nSarah: On API rate limiting — we'\''re seeing 429s from Pro plan customers.\nJames: Bump Pro from 100 to 200 req/min. Action item for me.\nPriya: Also add a retry-after header.\n\nAction items:\n- James: Bump Pro rate limit to 200 req/min\n- Priya: Add retry-after header to 429 responses\n- Sarah: Write ADR for Valkey decision"
      }
    }'
  ```

  ```python Python theme={null}
  transcript = "Attendees: Sarah, James, Priya\n\nDecision: Use Valkey for caching..."  # full text
  node = requests.post(f"{BASE}/boards/{board_id}/nodes", headers=headers, json={
      "type": "document", "position": {"x": 0, "y": 0},
      "data": {"label": "Sprint Planning — March 17", "content": transcript},
  })
  node_id = node.json()["data"]["id"]
  ```
</CodeGroup>

## Step 3: Vectorize the transcript

```bash cURL theme={null}
curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/documents/vectorize \
  -H "Authorization: Bearer cgk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "content": "...(full transcript text)...",
    "node_id": "{nodeId}",
    "metadata": {"source": "sprint-planning", "date": "2026-03-17", "attendees": "Sarah, James, Priya"}
  }'
```

## Step 4: Ask AI to extract decisions and action items

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/chats \
    -H "Authorization: Bearer cgk_live_..." \
    -H "Content-Type: application/json" \
    -d '{"title": "Meeting Extraction"}'

  curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/chats/{chatId}/messages \
    -H "Authorization: Bearer cgk_live_..." \
    -H "Content-Type: application/json" \
    -d '{
      "content": "From the meeting notes on this board, extract: 1) All decisions (with rationale), 2) All action items (with owner and deadline), 3) Any open risks. Format each as a separate item.",
      "stream": false
    }'
  ```

  ```typescript Node.js theme={null}
  const chatRes = await fetch(`https://api.chatgrid.ai/v1/boards/${boardId}/chats`, {
    method: "POST",
    headers: { Authorization: "Bearer cgk_live_...", "Content-Type": "application/json" },
    body: JSON.stringify({ title: "Meeting Extraction" }),
  });
  const { data: chat } = await chatRes.json();

  const msgRes = await fetch(
    `https://api.chatgrid.ai/v1/boards/${boardId}/chats/${chat.id}/messages`,
    {
      method: "POST",
      headers: { Authorization: "Bearer cgk_live_...", "Content-Type": "application/json" },
      body: JSON.stringify({
        content: "From the meeting notes on this board, extract: 1) All decisions (with rationale), 2) All action items (with owner and deadline), 3) Any open risks.",
        stream: false,
      }),
    }
  );
  const { data: extraction } = await msgRes.json();
  ```
</CodeGroup>

## Step 5: Create structured sticky notes

Batch-create a sticky note for each extracted item and link them to the source meeting.

```bash cURL theme={null}
curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/nodes/batch \
  -H "Authorization: Bearer cgk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "operations": [
      {"action": "create", "data": {"type": "note", "position": {"x": 0, "y": 400}, "data": {"label": "Decision", "text": "Use Valkey for caching. Rationale: OSS, Redis-compatible, no license risk. Deadline: March 28."}}},
      {"action": "create", "data": {"type": "note", "position": {"x": 400, "y": 400}, "data": {"label": "Action: James", "text": "Bump Pro rate limit from 100 to 200 req/min."}}},
      {"action": "create", "data": {"type": "note", "position": {"x": 800, "y": 400}, "data": {"label": "Action: Priya", "text": "Add retry-after header to all 429 responses."}}},
      {"action": "create", "data": {"type": "note", "position": {"x": 400, "y": 600}, "data": {"label": "Action: Sarah", "text": "Write ADR for Valkey caching decision."}}}
    ]
  }'
```

Connect each item back to its source meeting:

```bash cURL theme={null}
curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/edges \
  -H "Authorization: Bearer cgk_live_..." \
  -H "Content-Type: application/json" \
  -d '{"source_node_id": "{decisionNodeId}", "target_node_id": "{meetingNodeId}", "data": {"label": "decided in"}}'
```

## Step 6: Build a weekly digest

After adding multiple meetings, ask AI to produce a digest across all of them.

```bash cURL theme={null}
curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/chats/{chatId}/messages \
  -H "Authorization: Bearer cgk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Generate a weekly digest of all meetings on this board. Group by: decisions made, action items with owners, and open risks. Keep it under 300 words.",
    "stream": false
  }'
```

Search past meetings for specific topics at any time:

```bash cURL theme={null}
curl -X POST https://api.chatgrid.ai/v1/boards/{boardId}/documents/search \
  -H "Authorization: Bearer cgk_live_..." \
  -H "Content-Type: application/json" \
  -d '{"query": "when did we decide on the caching layer?", "limit": 3}'
```

## What's happening under the hood

Meeting transcripts are chunked and embedded like any other document. By tagging each transcript with date and attendees in the metadata, search results carry full provenance. When AI extracts decisions and action items, it performs semantic search across all meeting chunks then reasons over the matches. The sticky notes you create are regular nodes -- you can vectorize them too, making decisions searchable independently of the raw transcript. Edges between sticky notes and meeting nodes create a traceable graph: every decision links back to the meeting where it was made.

## Next steps

<CardGroup cols={2}>
  <Card title="Document Synthesis" icon="files" href="/cookbooks/document-synthesis">
    Synthesize PDFs and reports into visual findings
  </Card>

  <Card title="Team Knowledge" icon="users" href="/cookbooks/team-knowledge">
    Share your meeting board across the team
  </Card>
</CardGroup>