createCtxWindow - context-window

Overview

createCtxWindow() creates a context window and registers it in the global registry. This allows you to retrieve the instance later using getCtxWindow() without passing it around your application.

Use this when you need to access the same context window from multiple modules or functions.

Signature

async function createCtxWindow(
  options: CreateContextWindowOptions
): Promise<void>

Parameters

options

CreateContextWindowOptions

required

Configuration object for the context windowThe namespace serves as both the Pinecone namespace and the registry key.

See Configuration documentation for detailed parameter descriptions.

Return Value

createCtxWindow() returns a Promise that resolves to void. The created instance is stored in the registry and can be retrieved using getCtxWindow().

Registry Pattern

The registry pattern is useful for applications with multiple context windows or when you need to access instances across different modules.

// module-a.ts - Create and register
import { createCtxWindow } from "context-window";

await createCtxWindow({
  namespace: "user-docs",
  data: ["./docs"],
  ai: { provider: "openai" },
  vectorStore: { provider: "pinecone" }
});

// module-b.ts - Retrieve and use
import { getCtxWindow } from "context-window";

const cw = getCtxWindow("user-docs");
const result = await cw.ask("How do I get started?");

Examples

Basic Usage

import { createCtxWindow, getCtxWindow } from "context-window";

// Create and register
await createCtxWindow({
  namespace: "api-docs",
  data: ["./api-documentation"],
  ai: { provider: "openai" },
  vectorStore: { provider: "pinecone" }
});

// Retrieve later
const cw = getCtxWindow("api-docs");
const result = await cw.ask("What authentication methods are supported?");

Multiple Context Windows

import { createCtxWindow, getCtxWindow } from "context-window";

// Create multiple context windows for different purposes
await Promise.all([
  createCtxWindow({
    namespace: "user-manual",
    data: ["./manuals/user"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  }),
  createCtxWindow({
    namespace: "admin-manual",
    data: ["./manuals/admin"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  }),
  createCtxWindow({
    namespace: "developer-docs",
    data: ["./docs/developers"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  })
]);

// Use them independently
const userCW = getCtxWindow("user-manual");
const adminCW = getCtxWindow("admin-manual");
const devCW = getCtxWindow("developer-docs");

const userAnswer = await userCW.ask("How do I change my password?");
const adminAnswer = await adminCW.ask("How do I manage users?");
const devAnswer = await devCW.ask("How do I integrate the API?");

API Route Example (Express)

import express from "express";
import { createCtxWindow, getCtxWindow } from "context-window";

const app = express();

// Initialize on startup
await createCtxWindow({
  namespace: "knowledge-base",
  data: ["./knowledge-base"],
  ai: { provider: "openai" },
  vectorStore: { provider: "pinecone" }
});

// Use in route handlers
app.post("/api/ask", async (req, res) => {
  try {
    const { question } = req.body;
    const cw = getCtxWindow("knowledge-base");
    const result = await cw.ask(question);

    res.json({
      answer: result.text,
      sources: result.sources
    });
  } catch (error) {
    res.status(500).json({ error: "Failed to process question" });
  }
});

app.listen(3000);

Modular Application

// init.ts - Initialization module
import { createCtxWindow } from "context-window";

export async function initializeContextWindows() {
  console.log("Initializing context windows...");

  await createCtxWindow({
    namespace: "products",
    data: ["./data/products"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  });

  await createCtxWindow({
    namespace: "support",
    data: ["./data/support"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  });

  console.log("Context windows ready!");
}

// products.service.ts - Product service
import { getCtxWindow } from "context-window";

export async function getProductInfo(question: string) {
  const cw = getCtxWindow("products");
  return await cw.ask(question);
}

// support.service.ts - Support service
import { getCtxWindow } from "context-window";

export async function getSupportAnswer(question: string) {
  const cw = getCtxWindow("support");
  return await cw.ask(question);
}

// main.ts - Entry point
import { initializeContextWindows } from "./init";
import { getProductInfo } from "./products.service";
import { getSupportAnswer } from "./support.service";

async function main() {
  await initializeContextWindows();

  const productAnswer = await getProductInfo("What are the features?");
  const supportAnswer = await getSupportAnswer("How do I reset my password?");

  console.log("Product:", productAnswer.text);
  console.log("Support:", supportAnswer.text);
}

main();

Best Practices

1. Initialize Early

Create and register context windows during application startup:

// Good: Initialize once at startup
async function startup() {
  await createCtxWindow({ namespace: "docs", /* ... */ });
  await startServer();
}

// Avoid: Creating on every request
app.get("/ask", async (req, res) => {
  // Bad: Re-creating on every request
  await createCtxWindow({ namespace: "docs", /* ... */ });
  // ...
});

2. Use Descriptive Names

Choose clear, descriptive index names:

// Good
await createCtxWindow({ namespace: "user-documentation", /* ... */ });
await createCtxWindow({ namespace: "api-reference", /* ... */ });
await createCtxWindow({ namespace: "troubleshooting-guide", /* ... */ });

// Avoid
await createCtxWindow({ namespace: "docs1", /* ... */ });
await createCtxWindow({ namespace: "data", /* ... */ });

3. Check Existence

Before creating, check if a context window already exists:

import { hasCtxWindow, createCtxWindow } from "context-window";

if (!hasCtxWindow("my-docs")) {
  await createCtxWindow({
    namespace: "my-docs",
    data: ["./docs"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  });
}

4. Cleanup When Done

Remove context windows when they’re no longer needed:

import { deleteCtxWindow } from "context-window";

// When done with a specific context window
deleteCtxWindow("temporary-docs");

// Or clear all
import { clearCtxWindows } from "context-window";
clearCtxWindows();

Error Handling

import { createCtxWindow, getCtxWindow } from "context-window";

try {
  await createCtxWindow({
    namespace: "my-docs",
    data: ["./documents"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  });
} catch (error) {
  console.error("Failed to create context window:", error);
  process.exit(1);
}

// Later, when retrieving
try {
  const cw = getCtxWindow("my-docs");
  const result = await cw.ask("Your question");
} catch (error) {
  // Error will be thrown if "my-docs" doesn't exist
  console.error("Context window not found:", error);
}

Utility Functions

The registry pattern works with several utility functions:

getCtxWindow()

Retrieve a registered context window

hasCtxWindow()

Check if a context window exists

deleteCtxWindow()

Remove a context window from registry

listCtxWindows()

Get all registered index names

When to Use

Use createCtxWindow() for:

Accessing the context window from multiple modules
Building web servers with route handlers
Managing multiple context windows
Cleaner code without passing instances around
Global access to instances across your application

getCtxWindow

Retrieve registered instances

Utility Functions

Registry management functions

ask()

Query context windows

Configuration

Detailed configuration options

​Overview

​Signature

​Parameters

​Return Value

​Registry Pattern

​Examples

​Basic Usage

​Multiple Context Windows

​API Route Example (Express)

​Modular Application

​Best Practices

​1. Initialize Early

​2. Use Descriptive Names

​3. Check Existence

​4. Cleanup When Done

​Error Handling

​Utility Functions

getCtxWindow()

hasCtxWindow()

deleteCtxWindow()

listCtxWindows()

​When to Use

​Related

getCtxWindow

Utility Functions

ask()

Configuration

Overview

Signature

Parameters

Return Value

Registry Pattern

Examples

Basic Usage

Multiple Context Windows

API Route Example (Express)

Modular Application

Best Practices

1. Initialize Early

2. Use Descriptive Names

3. Check Existence

4. Cleanup When Done

Error Handling

Utility Functions

When to Use

Related