getCtxWindow - context-window

Overview

getCtxWindow() retrieves a previously created and registered context window by its index name. This function works in conjunction with createCtxWindow().

Use this to access context windows that were registered using createCtxWindow().

Signature

function getCtxWindow(namespace: string): ContextWindow

Parameters

namespace

string

required

The unique identifier of the context window to retrieve. Must match the namespace used when creating the context window with createCtxWindow().

Return Value

ContextWindow

object

The registered context window instance

Show ContextWindow properties

ask

function

Method to query the context window for answers

async ask(question: string): Promise<AskResult>

See ask() documentation for details.

Errors

Throws an error if no context window with the specified namespace exists in the registry.

// Error message
Error: Context window with index name "non-existent" not found

Examples

Basic Usage

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

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

// Later, retrieve and use
const cw = getCtxWindow("documentation");
const result = await cw.ask("How do I get started?");

console.log(result.text);
console.log(result.sources);

Using Across Modules

// initialization.ts
import { createCtxWindow } from "context-window";

export async function initializeApp() {
  await createCtxWindow({
    namespace: "product-catalog",
    data: ["./products"],
    ai: { provider: "openai" },
    vectorStore: { provider: "pinecone" }
  });
}

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

export async function searchProducts(query: string) {
  const cw = getCtxWindow("product-catalog");
  return await cw.ask(query);
}

// api.route.ts
import { getCtxWindow } from "context-window";

app.get("/api/products/search", async (req, res) => {
  const { q } = req.query;
  const cw = getCtxWindow("product-catalog");
  const result = await cw.ask(q as string);

  res.json({
    answer: result.text,
    sources: result.sources
  });
});

Safe Retrieval with Error Handling

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

function safeGetCtxWindow(namespace: string) {
  if (!hasCtxWindow(namespace)) {
    throw new Error(`Context window '${namespace}' has not been initialized`);
  }
  return getCtxWindow(namespace);
}

// Usage
try {
  const cw = safeGetCtxWindow("my-docs");
  const result = await cw.ask("Your question");
} catch (error) {
  console.error("Context window not available:", error);
}

Multiple Context Windows

import { getCtxWindow } from "context-window";

async function answerUserQuestion(question: string, department: string) {
  let namespace: string;

  // Route to appropriate context window based on department
  switch (department) {
    case "sales":
      namespace = "sales-docs";
      break;
    case "support":
      namespace = "support-docs";
      break;
    case "engineering":
      namespace = "engineering-docs";
      break;
    default:
      throw new Error("Unknown department");
  }

  const cw = getCtxWindow(namespace);
  return await cw.ask(question);
}

// Usage
const salesAnswer = await answerUserQuestion(
  "What's our pricing?",
  "sales"
);

const supportAnswer = await answerUserQuestion(
  "How do I reset my password?",
  "support"
);

Express.js Middleware Pattern

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

const app = express();

// Middleware to attach context window to request
app.use((req, res, next) => {
  try {
    req.contextWindow = getCtxWindow("main-docs");
    next();
  } catch (error) {
    res.status(500).json({
      error: "Documentation service unavailable"
    });
  }
});

// Use in routes
app.post("/api/ask", async (req, res) => {
  const { question } = req.body;
  const result = await req.contextWindow.ask(question);
  res.json(result);
});

// TypeScript: Extend Express Request type
declare global {
  namespace Express {
    interface Request {
      contextWindow: ContextWindow;
    }
  }
}

Lazy Loading Pattern

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

// Create a lazy-loading wrapper
async function getOrCreateContextWindow(namespace: string, dataPath: string) {
  if (!hasCtxWindow(namespace)) {
    console.log(`Initializing ${namespace}...`);
    await createCtxWindow({
      namespace,
      data: [dataPath],
      ai: { provider: "openai" },
      vectorStore: { provider: "pinecone" }
    });
  }
  return getCtxWindow(namespace);
}

// Usage - creates on first access
const cw = await getOrCreateContextWindow("docs", "./documentation");
const result = await cw.ask("Your question");

Best Practices

1. Check Before Retrieving

Always verify a context window exists before retrieving:

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

if (hasCtxWindow("my-docs")) {
  const cw = getCtxWindow("my-docs");
  // Use it
} else {
  console.error("Context window not initialized");
}

2. Use Constants for Index Names

Define index names as constants to avoid typos:

// constants.ts
export const CTX_WINDOWS = {
  USER_DOCS: "user-documentation",
  ADMIN_DOCS: "admin-documentation",
  API_REFERENCE: "api-reference"
} as const;

// usage.ts
import { getCtxWindow } from "context-window";
import { CTX_WINDOWS } from "./constants";

const cw = getCtxWindow(CTX_WINDOWS.USER_DOCS);

3. Centralize Access

Create a service layer for accessing context windows:

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

export class ContextWindowService {
  private static get(name: string) {
    try {
      return getCtxWindow(name);
    } catch (error) {
      throw new Error(`Context window '${name}' not available`);
    }
  }

  static async askUserDocs(question: string) {
    const cw = this.get("user-docs");
    return await cw.ask(question);
  }

  static async askAPIDocs(question: string) {
    const cw = this.get("api-docs");
    return await cw.ask(question);
  }
}

// usage.ts
import { ContextWindowService } from "./context-window.service";

const answer = await ContextWindowService.askUserDocs("How do I start?");

Common Patterns

Singleton Pattern

class DocumentationService {
  private static instance: ContextWindow | null = null;

  static getInstance(): ContextWindow {
    if (!this.instance) {
      this.instance = getCtxWindow("documentation");
    }
    return this.instance;
  }

  static async ask(question: string) {
    const cw = this.getInstance();
    return await cw.ask(question);
  }
}

Factory Pattern

class ContextWindowFactory {
  static get(type: "user" | "admin" | "developer"): ContextWindow {
    const indexMap = {
      user: "user-docs",
      admin: "admin-docs",
      developer: "dev-docs"
    };

    return getCtxWindow(indexMap[type]);
  }
}

// Usage
const userCW = ContextWindowFactory.get("user");
const adminCW = ContextWindowFactory.get("admin");

Error Handling

import { getCtxWindow } from "context-window";

try {
  const cw = getCtxWindow("my-docs");
  const result = await cw.ask("Your question");
  console.log(result);
} catch (error) {
  if (error instanceof Error) {
    if (error.message.includes("not found")) {
      console.error("Context window hasn't been created yet");
      // Initialize it or return an error to the user
    } else {
      console.error("Unexpected error:", error.message);
    }
  }
}

Debugging Tips

List All Context Windows

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

// See all available context windows
const allWindows = listCtxWindows();
console.log("Available context windows:", allWindows);

// Verify specific window exists
if (allWindows.includes("my-docs")) {
  const cw = getCtxWindow("my-docs");
}

Log on Retrieval

import { getCtxWindow } from "context-window";

function debugGetCtxWindow(namespace: string) {
  console.log(`Retrieving context window: ${namespace}`);
  const cw = getCtxWindow(namespace);
  console.log(`Successfully retrieved: ${namespace}`);
  return cw;
}

createCtxWindow

Create and register a context window

hasCtxWindow

Check if a context window exists

ask()

Query a context window

Utility Functions

Registry management functions

​Overview

​Signature

​Parameters

​Return Value

​Errors

​Examples

​Basic Usage

​Using Across Modules

​Safe Retrieval with Error Handling

​Multiple Context Windows

​Express.js Middleware Pattern

​Lazy Loading Pattern

​Best Practices

​1. Check Before Retrieving

​2. Use Constants for Index Names

​3. Centralize Access

​Common Patterns

​Singleton Pattern

​Factory Pattern

​Error Handling

​Debugging Tips

​List All Context Windows

​Log on Retrieval

​Related

createCtxWindow

hasCtxWindow

ask()

Utility Functions

Overview

Signature

Parameters

Return Value

Errors

Examples

Basic Usage

Using Across Modules

Safe Retrieval with Error Handling

Multiple Context Windows

Express.js Middleware Pattern

Lazy Loading Pattern

Best Practices

1. Check Before Retrieving

2. Use Constants for Index Names

3. Centralize Access

Common Patterns

Singleton Pattern

Factory Pattern

Error Handling

Debugging Tips

List All Context Windows

Log on Retrieval

Related