groq-rag 0.1.0

package/dist/index.js

@@ -0,0 +1,1903 @@
+// src/client.ts
+import Groq2 from "groq-sdk";
+
+// src/utils/chunker.ts
+var TextChunker = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      strategy: options.strategy || "recursive",
+      chunkSize: options.chunkSize || 1e3,
+      chunkOverlap: options.chunkOverlap || 200,
+      separators: options.separators || ["\n\n", "\n", ". ", " ", ""]
+    };
+  }
+  /**
+   * Chunk text into smaller pieces
+   */
+  chunk(text, documentId) {
+    switch (this.options.strategy) {
+      case "fixed":
+        return this.fixedChunk(text, documentId);
+      case "sentence":
+        return this.sentenceChunk(text, documentId);
+      case "paragraph":
+        return this.paragraphChunk(text, documentId);
+      case "recursive":
+        return this.recursiveChunk(text, documentId);
+      case "semantic":
+        return this.semanticChunk(text, documentId);
+      default:
+        return this.recursiveChunk(text, documentId);
+    }
+  }
+  /**
+   * Fixed-size chunking with overlap
+   */
+  fixedChunk(text, documentId) {
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+      const end = Math.min(start + this.options.chunkSize, text.length);
+      const content = text.slice(start, end).trim();
+      if (content) {
+        chunks.push({
+          id: `${documentId}-chunk-${chunks.length}`,
+          documentId,
+          content,
+          startIndex: start,
+          endIndex: end
+        });
+      }
+      start += this.options.chunkSize - this.options.chunkOverlap;
+    }
+    return chunks;
+  }
+  /**
+   * Sentence-based chunking
+   */
+  sentenceChunk(text, documentId) {
+    const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+    const chunks = [];
+    let currentChunk = "";
+    let startIndex = 0;
+    for (const sentence of sentences) {
+      if ((currentChunk + sentence).length > this.options.chunkSize && currentChunk) {
+        chunks.push({
+          id: `${documentId}-chunk-${chunks.length}`,
+          documentId,
+          content: currentChunk.trim(),
+          startIndex,
+          endIndex: startIndex + currentChunk.length
+        });
+        startIndex += currentChunk.length;
+        currentChunk = sentence;
+      } else {
+        currentChunk += sentence;
+      }
+    }
+    if (currentChunk.trim()) {
+      chunks.push({
+        id: `${documentId}-chunk-${chunks.length}`,
+        documentId,
+        content: currentChunk.trim(),
+        startIndex,
+        endIndex: startIndex + currentChunk.length
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Paragraph-based chunking
+   */
+  paragraphChunk(text, documentId) {
+    const paragraphs = text.split(/\n\n+/);
+    const chunks = [];
+    let currentChunk = "";
+    let startIndex = 0;
+    for (const paragraph of paragraphs) {
+      const trimmed = paragraph.trim();
+      if (!trimmed) continue;
+      if ((currentChunk + "\n\n" + trimmed).length > this.options.chunkSize && currentChunk) {
+        chunks.push({
+          id: `${documentId}-chunk-${chunks.length}`,
+          documentId,
+          content: currentChunk.trim(),
+          startIndex,
+          endIndex: startIndex + currentChunk.length
+        });
+        startIndex += currentChunk.length;
+        currentChunk = trimmed;
+      } else {
+        currentChunk = currentChunk ? currentChunk + "\n\n" + trimmed : trimmed;
+      }
+    }
+    if (currentChunk.trim()) {
+      chunks.push({
+        id: `${documentId}-chunk-${chunks.length}`,
+        documentId,
+        content: currentChunk.trim(),
+        startIndex,
+        endIndex: startIndex + currentChunk.length
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Recursive character text splitter (LangChain-style)
+   */
+  recursiveChunk(text, documentId) {
+    return this.recursiveSplit(text, this.options.separators, documentId);
+  }
+  recursiveSplit(text, separators, documentId, chunks = []) {
+    const separator = separators[0];
+    const remainingSeparators = separators.slice(1);
+    let splits;
+    if (separator === "") {
+      splits = text.split("");
+    } else {
+      splits = text.split(separator);
+    }
+    let currentChunk = "";
+    for (const split of splits) {
+      const piece = separator === "" ? split : split + separator;
+      if ((currentChunk + piece).length > this.options.chunkSize) {
+        if (currentChunk) {
+          if (currentChunk.length > this.options.chunkSize && remainingSeparators.length > 0) {
+            this.recursiveSplit(currentChunk, remainingSeparators, documentId, chunks);
+          } else {
+            chunks.push({
+              id: `${documentId}-chunk-${chunks.length}`,
+              documentId,
+              content: currentChunk.trim()
+            });
+          }
+        }
+        currentChunk = piece;
+      } else {
+        currentChunk += piece;
+      }
+    }
+    if (currentChunk.trim()) {
+      if (currentChunk.length > this.options.chunkSize && remainingSeparators.length > 0) {
+        this.recursiveSplit(currentChunk, remainingSeparators, documentId, chunks);
+      } else {
+        chunks.push({
+          id: `${documentId}-chunk-${chunks.length}`,
+          documentId,
+          content: currentChunk.trim()
+        });
+      }
+    }
+    return chunks;
+  }
+  /**
+   * Semantic chunking (placeholder - would use embeddings in production)
+   */
+  semanticChunk(text, documentId) {
+    return this.paragraphChunk(text, documentId);
+  }
+};
+function chunkText(text, documentId, options) {
+  const chunker = new TextChunker(options);
+  return chunker.chunk(text, documentId);
+}
+
+// src/utils/helpers.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  normA = Math.sqrt(normA);
+  normB = Math.sqrt(normB);
+  if (normA === 0 || normB === 0) {
+    return 0;
+  }
+  return dotProduct / (normA * normB);
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokens(text, maxTokens) {
+  const estimatedChars = maxTokens * 4;
+  if (text.length <= estimatedChars) {
+    return text;
+  }
+  return text.slice(0, estimatedChars) + "...";
+}
+function cleanText(text) {
+  return text.replace(/\n{3,}/g, "\n\n").replace(/[^\S\n]+/g, " ").replace(/ ?\n ?/g, "\n").trim();
+}
+function extractUrls(text) {
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g;
+  return text.match(urlRegex) || [];
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const { maxRetries = 3, baseDelay = 1e3, maxDelay = 1e4 } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries) {
+        const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function formatContext(results, options = {}) {
+  const { includeMetadata = false, separator = "\n\n---\n\n" } = options;
+  return results.map((result, index) => {
+    let text = `[Source ${index + 1}]
+${result.content}`;
+    if (includeMetadata && result.metadata) {
+      const meta = Object.entries(result.metadata).filter(([_, v]) => v !== void 0).map(([k, v]) => `${k}: ${v}`).join(", ");
+      if (meta) {
+        text = `[Source ${index + 1} | ${meta}]
+${result.content}`;
+      }
+    }
+    return text;
+  }).join(separator);
+}
+function safeJsonParse(text, defaultValue) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return defaultValue;
+  }
+}
+function batch(array, size) {
+  const batches = [];
+  for (let i = 0; i < array.length; i += size) {
+    batches.push(array.slice(i, i + size));
+  }
+  return batches;
+}
+
+// src/rag/retriever.ts
+var Retriever = class {
+  vectorStore;
+  embeddings;
+  chunker;
+  constructor(vectorStore, embeddings, chunkingOptions) {
+    this.vectorStore = vectorStore;
+    this.embeddings = embeddings;
+    this.chunker = new TextChunker(chunkingOptions);
+  }
+  /**
+   * Add a document to the retriever
+   */
+  async addDocument(content, metadata) {
+    const documentId = generateId();
+    const chunks = this.chunker.chunk(content, documentId);
+    const chunksWithMetadata = chunks.map((chunk) => ({
+      ...chunk,
+      metadata: { ...metadata, documentId }
+    }));
+    const texts = chunksWithMetadata.map((c) => c.content);
+    const embedResults = await this.embeddings.embedBatch(texts);
+    const chunksWithEmbeddings = chunksWithMetadata.map(
+      (chunk, i) => ({
+        ...chunk,
+        embedding: embedResults[i].embedding
+      })
+    );
+    await this.vectorStore.add(chunksWithEmbeddings);
+    return documentId;
+  }
+  /**
+   * Add multiple documents
+   */
+  async addDocuments(documents) {
+    const ids = [];
+    for (const doc of documents) {
+      const id = await this.addDocument(doc.content, doc.metadata);
+      ids.push(id);
+    }
+    return ids;
+  }
+  /**
+   * Add raw text directly (without chunking)
+   */
+  async addChunk(content, metadata) {
+    const id = generateId();
+    const [embedResult] = await this.embeddings.embedBatch([content]);
+    const chunk = {
+      id,
+      documentId: id,
+      content,
+      metadata,
+      embedding: embedResult.embedding
+    };
+    await this.vectorStore.add([chunk]);
+    return id;
+  }
+  /**
+   * Retrieve relevant documents for a query
+   */
+  async retrieve(query, options = {}) {
+    const { topK = 5, minScore = 0 } = options;
+    const { embedding } = await this.embeddings.embed(query);
+    const results = await this.vectorStore.search(embedding, { topK: topK * 2 });
+    return results.filter((r) => r.score >= minScore).slice(0, topK);
+  }
+  /**
+   * Retrieve and format context for LLM
+   */
+  async getContext(query, options = {}) {
+    const results = await this.retrieve(query, options);
+    return formatContext(
+      results.map((r) => ({
+        content: r.document.content,
+        metadata: r.document.metadata
+      })),
+      { includeMetadata: options.includeMetadata }
+    );
+  }
+  /**
+   * Delete documents by ID
+   */
+  async deleteDocuments(ids) {
+    await this.vectorStore.delete(ids);
+  }
+  /**
+   * Clear all documents
+   */
+  async clear() {
+    await this.vectorStore.clear();
+  }
+  /**
+   * Get document count
+   */
+  async count() {
+    return this.vectorStore.count();
+  }
+};
+function createRetriever(vectorStore, embeddings, options) {
+  return new Retriever(vectorStore, embeddings, options);
+}
+
+// src/rag/vectorStore.ts
+var MemoryVectorStore = class {
+  documents = /* @__PURE__ */ new Map();
+  async add(documents) {
+    for (const doc of documents) {
+      this.documents.set(doc.id, doc);
+    }
+  }
+  async search(queryEmbedding, options = {}) {
+    const { topK = 5, filter } = options;
+    const results = [];
+    for (const doc of this.documents.values()) {
+      if (!doc.embedding) continue;
+      if (filter && doc.metadata) {
+        let matches = true;
+        for (const [key, value] of Object.entries(filter)) {
+          if (doc.metadata[key] !== value) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      const score = cosineSimilarity(queryEmbedding, doc.embedding);
+      results.push({
+        document: doc,
+        score,
+        relevance: score > 0.8 ? "high" : score > 0.5 ? "medium" : "low"
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  async delete(ids) {
+    for (const id of ids) {
+      this.documents.delete(id);
+    }
+  }
+  async clear() {
+    this.documents.clear();
+  }
+  async count() {
+    return this.documents.size;
+  }
+  /**
+   * Get all documents (useful for debugging)
+   */
+  getAll() {
+    return Array.from(this.documents.values());
+  }
+};
+var ChromaVectorStore = class {
+  baseURL;
+  collectionName;
+  collectionId;
+  constructor(config) {
+    this.baseURL = config.connectionString || "http://localhost:8000";
+    this.collectionName = config.indexName || "groq-rag";
+  }
+  async ensureCollection() {
+    if (this.collectionId) return;
+    const response = await fetch(`${this.baseURL}/api/v1/collections`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: this.collectionName })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      this.collectionId = data.id;
+    } else {
+      const getResponse = await fetch(
+        `${this.baseURL}/api/v1/collections/${this.collectionName}`
+      );
+      if (getResponse.ok) {
+        const data = await getResponse.json();
+        this.collectionId = data.id;
+      }
+    }
+  }
+  async add(documents) {
+    await this.ensureCollection();
+    const ids = documents.map((d) => d.id);
+    const embeddings = documents.map((d) => d.embedding || []);
+    const metadatas = documents.map((d) => d.metadata || {});
+    const contents = documents.map((d) => d.content);
+    await fetch(`${this.baseURL}/api/v1/collections/${this.collectionId}/add`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ids,
+        embeddings,
+        metadatas,
+        documents: contents
+      })
+    });
+  }
+  async search(queryEmbedding, options = {}) {
+    await this.ensureCollection();
+    const { topK = 5, filter } = options;
+    const response = await fetch(
+      `${this.baseURL}/api/v1/collections/${this.collectionId}/query`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query_embeddings: [queryEmbedding],
+          n_results: topK,
+          where: filter
+        })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Chroma query failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const results = [];
+    const ids = data.ids[0] || [];
+    const distances = data.distances[0] || [];
+    const docs = data.documents[0] || [];
+    const metas = data.metadatas[0] || [];
+    for (let i = 0; i < ids.length; i++) {
+      const score = 1 - (distances[i] || 0);
+      results.push({
+        document: {
+          id: ids[i],
+          documentId: ids[i],
+          content: docs[i],
+          metadata: metas[i]
+        },
+        score,
+        relevance: score > 0.8 ? "high" : score > 0.5 ? "medium" : "low"
+      });
+    }
+    return results;
+  }
+  async delete(ids) {
+    await this.ensureCollection();
+    await fetch(`${this.baseURL}/api/v1/collections/${this.collectionId}/delete`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ids })
+    });
+  }
+  async clear() {
+    await fetch(`${this.baseURL}/api/v1/collections/${this.collectionName}`, {
+      method: "DELETE"
+    });
+    this.collectionId = void 0;
+    await this.ensureCollection();
+  }
+  async count() {
+    await this.ensureCollection();
+    const response = await fetch(
+      `${this.baseURL}/api/v1/collections/${this.collectionId}/count`
+    );
+    const data = await response.json();
+    return data;
+  }
+};
+function createVectorStore(config) {
+  switch (config.provider) {
+    case "chroma":
+      return new ChromaVectorStore(config);
+    case "memory":
+    default:
+      return new MemoryVectorStore();
+  }
+}
+
+// src/rag/embeddings.ts
+import Groq from "groq-sdk";
+var GroqEmbeddings = class {
+  client;
+  model;
+  dimensions;
+  constructor(config) {
+    this.client = config.groqClient || new Groq({ apiKey: config.apiKey });
+    this.model = config.model || "llama-3.3-70b-versatile";
+    this.dimensions = config.dimensions || 1536;
+  }
+  async embed(text) {
+    const embedding = await this.generatePseudoEmbedding(text);
+    return { embedding, tokenCount: Math.ceil(text.length / 4) };
+  }
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embed(text));
+    }
+    return results;
+  }
+  /**
+   * Generate a pseudo-embedding (for demo purposes)
+   * In production, replace with actual embedding API
+   */
+  async generatePseudoEmbedding(text) {
+    const embedding = new Array(this.dimensions).fill(0);
+    for (let i = 0; i < text.length; i++) {
+      const charCode = text.charCodeAt(i);
+      const index = charCode * (i + 1) % this.dimensions;
+      embedding[index] += 1 / Math.sqrt(text.length);
+    }
+    const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+    if (norm > 0) {
+      for (let i = 0; i < embedding.length; i++) {
+        embedding[i] /= norm;
+      }
+    }
+    return embedding;
+  }
+};
+var OpenAIEmbeddings = class {
+  apiKey;
+  baseURL;
+  model;
+  dimensions;
+  constructor(config) {
+    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || "";
+    this.baseURL = config.baseURL || "https://api.openai.com/v1";
+    this.model = config.model || "text-embedding-3-small";
+    this.dimensions = config.dimensions || 1536;
+  }
+  async embed(text) {
+    const response = await fetch(`${this.baseURL}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        input: text,
+        model: this.model,
+        dimensions: this.dimensions
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Embedding request failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      embedding: data.data[0].embedding,
+      tokenCount: data.usage?.total_tokens
+    };
+  }
+  async embedBatch(texts) {
+    const batches = batch(texts, 100);
+    const results = [];
+    for (const batchTexts of batches) {
+      const response = await fetch(`${this.baseURL}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          input: batchTexts,
+          model: this.model,
+          dimensions: this.dimensions
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Embedding request failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      for (const item of data.data) {
+        results.push({
+          embedding: item.embedding,
+          tokenCount: data.usage?.total_tokens ? Math.floor(data.usage.total_tokens / batchTexts.length) : void 0
+        });
+      }
+    }
+    return results;
+  }
+};
+function createEmbeddingProvider(config, groqClient) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIEmbeddings(config);
+    case "groq":
+    case "local":
+    default:
+      return new GroqEmbeddings({ ...config, groqClient });
+  }
+}
+
+// src/web/fetcher.ts
+import * as cheerio from "cheerio";
+import TurndownService from "turndown";
+var WebFetcher = class {
+  config;
+  turndown;
+  constructor(config = {}) {
+    this.config = {
+      userAgent: config.userAgent || "Mozilla/5.0 (compatible; GroqRAG/1.0; +https://github.com/mithun50/groq-rag)",
+      timeout: config.timeout || 3e4,
+      maxContentLength: config.maxContentLength || 1e6,
+      // 1MB
+      followRedirects: config.followRedirects ?? true,
+      proxy: config.proxy
+    };
+    this.turndown = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    this.turndown.addRule("removeScripts", {
+      filter: ["script", "style", "noscript", "iframe"],
+      replacement: () => ""
+    });
+    this.turndown.addRule("preserveCode", {
+      filter: "pre",
+      replacement: (content, node) => {
+        const code = node.textContent || content;
+        return `
+\`\`\`
+${code}
+\`\`\`
+`;
+      }
+    });
+  }
+  /**
+   * Fetch a URL and extract content
+   */
+  async fetch(url, options = {}) {
+    const {
+      headers = {},
+      timeout = this.config.timeout,
+      extractText = true,
+      includeLinks = false,
+      includeImages = false
+    } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": this.config.userAgent,
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "Accept-Language": "en-US,en;q=0.5",
+          ...headers
+        },
+        redirect: this.config.followRedirects ? "follow" : "manual",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const html = await response.text();
+      clearTimeout(timeoutId);
+      const $ = cheerio.load(html);
+      $("script, style, noscript, iframe, nav, footer, aside, .ads, .advertisement").remove();
+      const title = $("title").text().trim() || $("h1").first().text().trim() || $('meta[property="og:title"]').attr("content") || void 0;
+      const metadata = {
+        description: $('meta[name="description"]').attr("content") || $('meta[property="og:description"]').attr("content") || void 0,
+        author: $('meta[name="author"]').attr("content") || $('meta[property="article:author"]').attr("content") || void 0,
+        publishedDate: $('meta[property="article:published_time"]').attr("content") || $("time").attr("datetime") || void 0
+      };
+      let content = "";
+      let markdown = "";
+      if (extractText) {
+        const mainSelectors = [
+          "main",
+          "article",
+          '[role="main"]',
+          ".content",
+          ".post-content",
+          ".article-content",
+          ".entry-content",
+          "#content",
+          "#main"
+        ];
+        let mainHtml = $("body").html() || "";
+        let mainText = $("body").text();
+        for (const selector of mainSelectors) {
+          const selected = $(selector);
+          if (selected.length > 0) {
+            mainHtml = selected.first().html() || mainHtml;
+            mainText = selected.first().text();
+            break;
+          }
+        }
+        markdown = this.turndown.turndown(mainHtml);
+        content = mainText.replace(/\s+/g, " ").trim();
+      }
+      let links;
+      if (includeLinks) {
+        links = [];
+        $("a[href]").each((_, el) => {
+          const $el = $(el);
+          const href = $el.attr("href");
+          const text = $el.text().trim();
+          if (href && text && !href.startsWith("#") && !href.startsWith("javascript:")) {
+            try {
+              const absoluteUrl = new URL(href, url).toString();
+              links.push({ text, href: absoluteUrl });
+            } catch {
+            }
+          }
+        });
+        links = [...new Map(links.map((l) => [l.href, l])).values()];
+      }
+      let images;
+      if (includeImages) {
+        images = [];
+        $("img[src]").each((_, el) => {
+          const $el = $(el);
+          const src = $el.attr("src");
+          const alt = $el.attr("alt") || "";
+          if (src) {
+            try {
+              const absoluteUrl = new URL(src, url).toString();
+              images.push({ alt, src: absoluteUrl });
+            } catch {
+            }
+          }
+        });
+      }
+      return {
+        url,
+        title,
+        content,
+        markdown,
+        links,
+        images,
+        metadata,
+        fetchedAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Fetch multiple URLs in parallel
+   */
+  async fetchMany(urls, options = {}) {
+    const results = await Promise.allSettled(
+      urls.map((url) => this.fetch(url, options))
+    );
+    return results.map((result, i) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      } else {
+        return new Error(`Failed to fetch ${urls[i]}: ${result.reason}`);
+      }
+    });
+  }
+  /**
+   * Fetch and extract just the text content
+   */
+  async fetchText(url) {
+    const result = await this.fetch(url, { extractText: true });
+    return result.content;
+  }
+  /**
+   * Fetch and convert to markdown
+   */
+  async fetchMarkdown(url) {
+    const result = await this.fetch(url, { extractText: true });
+    return result.markdown || result.content;
+  }
+};
+function createFetcher(config) {
+  return new WebFetcher(config);
+}
+
+// src/web/search.ts
+var DuckDuckGoSearch = class {
+  baseUrl = "https://html.duckduckgo.com/html/";
+  async search(query, options = {}) {
+    const { maxResults = 10 } = options;
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "User-Agent": "Mozilla/5.0 (compatible; GroqRAG/1.0)"
+        },
+        body: `q=${encodeURIComponent(query)}`
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.statusText}`);
+      }
+      const html = await response.text();
+      const results = this.parseResults(html, maxResults);
+      return results;
+    } catch (error) {
+      console.error("DuckDuckGo search error:", error);
+      return [];
+    }
+  }
+  parseResults(html, maxResults) {
+    const results = [];
+    const resultRegex = /<a[^>]+class="result__a"[^>]*href="([^"]+)"[^>]*>([^<]+)<\/a>/gi;
+    const snippetRegex = /<a[^>]+class="result__snippet"[^>]*>([^<]+(?:<[^>]+>[^<]+<\/[^>]+>)*[^<]*)<\/a>/gi;
+    let match;
+    let position = 1;
+    while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+      const url = this.decodeUrl(match[1]);
+      const title = this.decodeHtml(match[2]);
+      const snippetMatch = snippetRegex.exec(html);
+      const snippet = snippetMatch ? this.decodeHtml(snippetMatch[1].replace(/<[^>]+>/g, "")) : "";
+      if (url && title && !url.includes("duckduckgo.com")) {
+        results.push({
+          title,
+          url,
+          snippet,
+          position: position++
+        });
+      }
+    }
+    return results;
+  }
+  decodeUrl(url) {
+    try {
+      const decoded = decodeURIComponent(url);
+      const match = decoded.match(/uddg=([^&]+)/);
+      if (match) {
+        return decodeURIComponent(match[1]);
+      }
+      return decoded;
+    } catch {
+      return url;
+    }
+  }
+  decodeHtml(html) {
+    return html.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").trim();
+  }
+};
+var BraveSearch = class {
+  apiKey;
+  baseUrl = "https://api.search.brave.com/res/v1/web/search";
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async search(query, options = {}) {
+    const { maxResults = 10, safeSearch = true } = options;
+    const params = new URLSearchParams({
+      q: query,
+      count: String(maxResults),
+      safesearch: safeSearch ? "moderate" : "off"
+    });
+    const response = await fetch(`${this.baseUrl}?${params}`, {
+      headers: {
+        "Accept": "application/json",
+        "X-Subscription-Token": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Brave search failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return (data.web?.results || []).map((result, index) => ({
+      title: result.title,
+      url: result.url,
+      snippet: result.description,
+      position: index + 1
+    }));
+  }
+};
+var SerperSearch = class {
+  apiKey;
+  baseUrl = "https://google.serper.dev/search";
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async search(query, options = {}) {
+    const { maxResults = 10 } = options;
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": this.apiKey
+      },
+      body: JSON.stringify({
+        q: query,
+        num: maxResults
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Serper search failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return (data.organic || []).map((result) => ({
+      title: result.title,
+      url: result.link,
+      snippet: result.snippet,
+      position: result.position
+    }));
+  }
+};
+function createSearchProvider(config) {
+  const { provider = "duckduckgo", apiKey } = config || {};
+  switch (provider) {
+    case "brave":
+      if (!apiKey) throw new Error("Brave Search requires an API key");
+      return new BraveSearch(apiKey);
+    case "serper":
+      if (!apiKey) throw new Error("Serper Search requires an API key");
+      return new SerperSearch(apiKey);
+    case "duckduckgo":
+    default:
+      return new DuckDuckGoSearch();
+  }
+}
+
+// src/tools/executor.ts
+var ToolExecutor = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(tools = []) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /**
+   * Register a tool
+   */
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get tools in Groq API format
+   */
+  getToolsForAPI() {
+    return this.getTools().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Execute a tool by name
+   */
+  async execute(name, params) {
+    const startTime = Date.now();
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        name,
+        result: null,
+        error: `Tool "${name}" not found`,
+        executionTime: Date.now() - startTime
+      };
+    }
+    try {
+      const result = await tool.execute(params);
+      return {
+        name,
+        result,
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        name,
+        result: null,
+        error: error instanceof Error ? error.message : String(error),
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Execute multiple tool calls in parallel
+   */
+  async executeMany(calls) {
+    return Promise.all(
+      calls.map((call) => this.execute(call.name, call.params))
+    );
+  }
+  /**
+   * Process tool calls from Groq API response
+   */
+  async processToolCalls(toolCalls) {
+    const results = await Promise.all(
+      toolCalls.map(async (toolCall) => {
+        let params = {};
+        try {
+          params = JSON.parse(toolCall.function.arguments);
+        } catch {
+        }
+        const result = await this.execute(toolCall.function.name, params);
+        return {
+          toolCallId: toolCall.id,
+          result
+        };
+      })
+    );
+    return results;
+  }
+  /**
+   * Format tool results as messages for Groq API
+   */
+  formatToolResultsAsMessages(results) {
+    return results.map(({ toolCallId, result }) => ({
+      role: "tool",
+      tool_call_id: toolCallId,
+      content: result.error ? `Error: ${result.error}` : JSON.stringify(result.result)
+    }));
+  }
+};
+function createToolExecutor(tools) {
+  return new ToolExecutor(tools);
+}
+
+// src/agents/agent.ts
+function parseTextFunctionCall(text) {
+  const match = text.match(/<function=(\w+)(\{[\s\S]*?\})<\/function>/);
+  if (match) {
+    try {
+      const name = match[1];
+      const args = JSON.parse(match[2]);
+      return { name, args };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function extractFailedGeneration(error) {
+  if (error instanceof Error) {
+    const jsonMatch = error.message.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return parsed.error?.failed_generation || null;
+      } catch {
+        return null;
+      }
+    }
+  }
+  const err = error;
+  return err.error?.failed_generation || null;
+}
+var Agent = class {
+  client;
+  config;
+  executor;
+  messages;
+  constructor(client, config = {}) {
+    this.client = client;
+    this.config = {
+      name: config.name || "Agent",
+      model: config.model || "llama-3.3-70b-versatile",
+      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(),
+      tools: config.tools || [],
+      maxIterations: config.maxIterations || 10,
+      verbose: config.verbose ?? false,
+      memory: config.memory || { messages: [] }
+    };
+    this.executor = new ToolExecutor(this.config.tools);
+    this.messages = [
+      { role: "system", content: this.config.systemPrompt },
+      ...this.config.memory.messages
+    ];
+  }
+  getDefaultSystemPrompt() {
+    return `You are a helpful AI assistant. You have access to tools that you can use to help answer questions.
+
+IMPORTANT: When you need to use a tool, the system will automatically handle the tool calling for you. Just respond naturally and the tools will be invoked through the API's function calling mechanism. Do NOT write out function calls as text like "<function=..." - that format is not supported.
+
+Available capabilities:
+- Search the web for current information
+- Fetch and read content from URLs
+- Query the knowledge base for indexed documents
+- Perform mathematical calculations
+- Get current date and time
+
+When you don't know something or need current information, use the appropriate tool. Provide clear, helpful responses based on the information you gather.`;
+  }
+  /**
+   * Add a tool to the agent
+   */
+  addTool(tool) {
+    this.config.tools.push(tool);
+    this.executor.register(tool);
+  }
+  /**
+   * Run the agent with a user message
+   */
+  async run(input) {
+    const steps = [];
+    const toolCalls = [];
+    this.messages.push({ role: "user", content: input });
+    let iteration = 0;
+    let totalTokens = 0;
+    while (iteration < this.config.maxIterations) {
+      iteration++;
+      if (this.config.verbose) {
+        console.log(`
+[Agent] Iteration ${iteration}`);
+      }
+      let response;
+      let textFunctionCall = null;
+      try {
+        response = await this.client.chat.completions.create({
+          model: this.config.model,
+          messages: this.messages,
+          tools: this.executor.getToolsForAPI(),
+          tool_choice: "auto"
+        });
+      } catch (error) {
+        const failedGen = extractFailedGeneration(error);
+        if (failedGen) {
+          textFunctionCall = parseTextFunctionCall(failedGen);
+          if (textFunctionCall) {
+            const result = await this.executor.execute(textFunctionCall.name, textFunctionCall.args);
+            toolCalls.push(result);
+            steps.push({
+              action: textFunctionCall.name,
+              actionInput: textFunctionCall.args,
+              observation: result.error || JSON.stringify(result.result)
+            });
+            this.messages.push({
+              role: "assistant",
+              content: `I'll use the ${textFunctionCall.name} tool to help with this.`
+            });
+            this.messages.push({
+              role: "user",
+              content: `Tool result: ${result.error || JSON.stringify(result.result)}`
+            });
+            continue;
+          }
+        }
+        throw error;
+      }
+      const choice = response.choices[0];
+      const message = choice.message;
+      totalTokens += response.usage?.total_tokens || 0;
+      this.messages.push(message);
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        if (this.config.verbose) {
+          console.log(`[Agent] Tool calls:`, message.tool_calls.map((tc) => tc.function.name));
+        }
+        const results = await this.executor.processToolCalls(message.tool_calls);
+        for (const { toolCallId, result } of results) {
+          const toolCall = message.tool_calls.find((tc) => tc.id === toolCallId);
+          steps.push({
+            action: toolCall?.function.name,
+            actionInput: toolCall ? JSON.parse(toolCall.function.arguments) : {},
+            observation: result.error || JSON.stringify(result.result)
+          });
+          toolCalls.push(result);
+        }
+        const toolMessages = this.executor.formatToolResultsAsMessages(results);
+        this.messages.push(...toolMessages);
+        if (this.config.verbose) {
+          console.log(`[Agent] Tool results:`, results.map((r) => r.result));
+        }
+      } else {
+        steps.push({
+          thought: message.content || "",
+          isFinal: true
+        });
+        if (this.config.verbose) {
+          console.log(`[Agent] Final response:`, message.content?.substring(0, 100));
+        }
+        return {
+          output: message.content || "",
+          steps,
+          toolCalls,
+          totalTokens
+        };
+      }
+      if (choice.finish_reason === "stop" && !message.tool_calls) {
+        steps.push({
+          thought: message.content || "",
+          isFinal: true
+        });
+        return {
+          output: message.content || "",
+          steps,
+          toolCalls,
+          totalTokens
+        };
+      }
+    }
+    return {
+      output: "Agent reached maximum iterations without completing the task.",
+      steps,
+      toolCalls,
+      totalTokens
+    };
+  }
+  /**
+   * Run with streaming output
+   */
+  async *runStream(input) {
+    this.messages.push({ role: "user", content: input });
+    let iteration = 0;
+    const steps = [];
+    const toolCalls = [];
+    while (iteration < this.config.maxIterations) {
+      iteration++;
+      let response;
+      try {
+        response = await this.client.chat.completions.create({
+          model: this.config.model,
+          messages: this.messages,
+          tools: this.executor.getToolsForAPI(),
+          tool_choice: "auto",
+          stream: true
+        });
+      } catch (error) {
+        const failedGen = extractFailedGeneration(error);
+        if (failedGen) {
+          const textFunctionCall = parseTextFunctionCall(failedGen);
+          if (textFunctionCall) {
+            yield { type: "tool_call", data: { name: textFunctionCall.name, arguments: JSON.stringify(textFunctionCall.args) } };
+            const result = await this.executor.execute(textFunctionCall.name, textFunctionCall.args);
+            yield { type: "tool_result", data: result };
+            toolCalls.push(result);
+            this.messages.push({
+              role: "assistant",
+              content: `Using ${textFunctionCall.name} tool.`
+            });
+            this.messages.push({
+              role: "user",
+              content: `Tool result: ${result.error || JSON.stringify(result.result)}`
+            });
+            continue;
+          }
+        }
+        throw error;
+      }
+      let content = "";
+      const currentToolCalls = [];
+      for await (const chunk of response) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          content += delta.content;
+          yield { type: "content", data: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (tc.index !== void 0) {
+              if (!currentToolCalls[tc.index]) {
+                currentToolCalls[tc.index] = {
+                  id: tc.id || "",
+                  type: "function",
+                  function: { name: tc.function?.name || "", arguments: "" }
+                };
+              }
+              if (tc.id) currentToolCalls[tc.index].id = tc.id;
+              if (tc.function?.name) currentToolCalls[tc.index].function.name = tc.function.name;
+              if (tc.function?.arguments) {
+                currentToolCalls[tc.index].function.arguments += tc.function.arguments;
+              }
+            }
+          }
+        }
+      }
+      if (currentToolCalls.length > 0) {
+        this.messages.push({
+          role: "assistant",
+          content: content || null,
+          tool_calls: currentToolCalls
+        });
+        for (const tc of currentToolCalls) {
+          yield { type: "tool_call", data: { name: tc.function.name, arguments: tc.function.arguments } };
+          const result = await this.executor.execute(
+            tc.function.name,
+            JSON.parse(tc.function.arguments || "{}")
+          );
+          yield { type: "tool_result", data: result };
+          toolCalls.push(result);
+          this.messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: result.error || JSON.stringify(result.result)
+          });
+        }
+      } else {
+        this.messages.push({ role: "assistant", content });
+        yield { type: "done", data: { output: content, steps, toolCalls } };
+        return;
+      }
+    }
+    yield { type: "done", data: { output: "Max iterations reached", steps, toolCalls } };
+  }
+  /**
+   * Clear conversation history
+   */
+  clearHistory() {
+    this.messages = [{ role: "system", content: this.config.systemPrompt }];
+  }
+  /**
+   * Get conversation history
+   */
+  getHistory() {
+    return [...this.messages];
+  }
+};
+function createAgent(client, config) {
+  return new Agent(client, config);
+}
+
+// src/tools/builtins.ts
+function createWebSearchTool(searchProvider = new DuckDuckGoSearch()) {
+  return {
+    name: "web_search",
+    description: "Search the web for information. Use this to find current information, news, or research topics.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        maxResults: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5)"
+        }
+      },
+      required: ["query"]
+    },
+    execute: async (params) => {
+      const { query, maxResults = 5 } = params;
+      const results = await searchProvider.search(query, { maxResults });
+      return results.map((r) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.snippet
+      }));
+    }
+  };
+}
+function createFetchUrlTool(fetcher = new WebFetcher()) {
+  return {
+    name: "fetch_url",
+    description: "Fetch and extract content from a URL. Use this to read web pages, articles, or documentation.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch"
+        },
+        includeLinks: {
+          type: "boolean",
+          description: "Include links found on the page (default: false)"
+        }
+      },
+      required: ["url"]
+    },
+    execute: async (params) => {
+      const { url, includeLinks = false } = params;
+      const result = await fetcher.fetch(url, { includeLinks });
+      return {
+        title: result.title,
+        content: result.markdown || result.content,
+        links: result.links?.slice(0, 10),
+        metadata: result.metadata
+      };
+    }
+  };
+}
+function createRAGQueryTool(retriever) {
+  return {
+    name: "rag_query",
+    description: "Search the knowledge base for relevant information. Use this to find information from indexed documents.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        topK: {
+          type: "number",
+          description: "Number of results to return (default: 5)"
+        }
+      },
+      required: ["query"]
+    },
+    execute: async (params) => {
+      const { query, topK = 5 } = params;
+      const results = await retriever.retrieve(query, { topK });
+      return results.map((r) => ({
+        content: r.document.content,
+        score: r.score,
+        metadata: r.document.metadata
+      }));
+    }
+  };
+}
+function createCalculatorTool() {
+  return {
+    name: "calculator",
+    description: "Perform mathematical calculations. Supports basic arithmetic, powers, and common math functions.",
+    parameters: {
+      type: "object",
+      properties: {
+        expression: {
+          type: "string",
+          description: 'The mathematical expression to evaluate (e.g., "2 + 2", "sqrt(16)", "pow(2, 8)")'
+        }
+      },
+      required: ["expression"]
+    },
+    execute: async (params) => {
+      const { expression } = params;
+      const sanitized = expression.replace(/[^0-9+\-*/().,%\s]/gi, "").replace(/pow/gi, "Math.pow").replace(/sqrt/gi, "Math.sqrt").replace(/abs/gi, "Math.abs").replace(/sin/gi, "Math.sin").replace(/cos/gi, "Math.cos").replace(/tan/gi, "Math.tan").replace(/log/gi, "Math.log").replace(/exp/gi, "Math.exp").replace(/pi/gi, "Math.PI").replace(/e(?![xp])/gi, "Math.E");
+      try {
+        if (!sanitized.trim()) {
+          return { expression, error: "Invalid expression" };
+        }
+        const result = new Function(`return ${sanitized}`)();
+        if (result === void 0 || typeof result === "number" && isNaN(result)) {
+          return { expression, error: "Invalid expression" };
+        }
+        return { expression, result };
+      } catch {
+        return { expression, error: "Invalid expression" };
+      }
+    }
+  };
+}
+function createDateTimeTool() {
+  return {
+    name: "get_datetime",
+    description: "Get the current date and time in a specific timezone.",
+    parameters: {
+      type: "object",
+      properties: {
+        timezone: {
+          type: "string",
+          description: 'Timezone (e.g., "UTC", "America/New_York", "Asia/Tokyo"). Defaults to UTC.'
+        }
+      },
+      required: []
+    },
+    execute: async (params) => {
+      const { timezone = "UTC" } = params;
+      const now = /* @__PURE__ */ new Date();
+      try {
+        const formatted = now.toLocaleString("en-US", { timeZone: timezone });
+        return {
+          datetime: formatted,
+          timezone,
+          timestamp: now.toISOString(),
+          unix: Math.floor(now.getTime() / 1e3)
+        };
+      } catch {
+        return {
+          datetime: now.toISOString(),
+          timezone: "UTC",
+          timestamp: now.toISOString(),
+          unix: Math.floor(now.getTime() / 1e3)
+        };
+      }
+    }
+  };
+}
+function getBuiltinTools() {
+  return [
+    createWebSearchTool(),
+    createFetchUrlTool(),
+    createCalculatorTool(),
+    createDateTimeTool()
+  ];
+}
+
+// src/client.ts
+var GroqRAG = class {
+  groq;
+  config;
+  retriever;
+  fetcher;
+  searchProvider;
+  chat;
+  web;
+  rag;
+  constructor(config = {}) {
+    this.config = config;
+    this.groq = new Groq2({
+      apiKey: config.apiKey || process.env.GROQ_API_KEY,
+      baseURL: config.baseURL,
+      timeout: config.timeout,
+      maxRetries: config.maxRetries
+    });
+    this.fetcher = createFetcher(config.web);
+    this.searchProvider = createSearchProvider();
+    this.chat = new ChatWithRAG(this);
+    this.web = new WebModule(this);
+    this.rag = new RAGModule(this);
+  }
+  /**
+   * Get the underlying Groq client
+   */
+  get client() {
+    return this.groq;
+  }
+  /**
+   * Initialize RAG with vector store and embeddings
+   */
+  async initRAG(options) {
+    const embeddingConfig = options?.embedding || {
+      provider: "groq"
+    };
+    const vectorStoreConfig = options?.vectorStore || {
+      provider: "memory"
+    };
+    const vectorStore = createVectorStore(vectorStoreConfig);
+    const embeddings = createEmbeddingProvider(embeddingConfig, this.groq);
+    this.retriever = createRetriever(vectorStore, embeddings, options?.chunking);
+    return this.retriever;
+  }
+  /**
+   * Get the retriever (initializes with defaults if not already initialized)
+   */
+  async getRetriever() {
+    if (!this.retriever) {
+      await this.initRAG();
+    }
+    return this.retriever;
+  }
+  /**
+   * Get the web fetcher
+   */
+  getFetcher() {
+    return this.fetcher;
+  }
+  /**
+   * Get the search provider
+   */
+  getSearchProvider() {
+    return this.searchProvider;
+  }
+  /**
+   * Create an agent with tools
+   */
+  createAgent(config) {
+    return createAgent(this.groq, config);
+  }
+  /**
+   * Create an agent with built-in tools (web search, fetch, RAG)
+   */
+  async createAgentWithBuiltins(config) {
+    const retriever = await this.getRetriever();
+    const tools = [
+      ...getBuiltinTools(),
+      createRAGQueryTool(retriever),
+      ...config?.tools || []
+    ];
+    return createAgent(this.groq, { ...config, tools });
+  }
+  /**
+   * Standard chat completions (passthrough to Groq)
+   */
+  async complete(params) {
+    return this.groq.chat.completions.create(params);
+  }
+  /**
+   * Streaming chat completions (passthrough to Groq)
+   */
+  stream(params) {
+    return this.groq.chat.completions.create(params);
+  }
+};
+var ChatWithRAG = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Chat with RAG-augmented context
+   */
+  async withRAG(options) {
+    const {
+      messages,
+      model = "llama-3.3-70b-versatile",
+      temperature = 0.7,
+      maxTokens = 1024,
+      topK = 5,
+      minScore = 0,
+      includeMetadata = false,
+      systemPrompt
+    } = options;
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUserMessage || typeof lastUserMessage.content !== "string") {
+      throw new Error("No user message found for RAG retrieval");
+    }
+    const retriever = await this.parent.getRetriever();
+    const results = await retriever.retrieve(lastUserMessage.content, {
+      topK,
+      minScore
+    });
+    const context = formatContext(
+      results.map((r) => ({
+        content: r.document.content,
+        metadata: r.document.metadata
+      })),
+      { includeMetadata }
+    );
+    const ragSystemPrompt = systemPrompt || `You are a helpful assistant. Use the following context to answer questions accurately.
+If the context doesn't contain relevant information, say so clearly.
+
+Context:
+${context}`;
+    const augmentedMessages = [
+      { role: "system", content: ragSystemPrompt },
+      ...messages
+    ];
+    const response = await this.parent.client.chat.completions.create({
+      model,
+      messages: augmentedMessages,
+      temperature,
+      max_tokens: maxTokens
+    });
+    return {
+      content: response.choices[0]?.message?.content || "",
+      sources: results,
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0
+    };
+  }
+  /**
+   * Chat with web search augmentation
+   */
+  async withWebSearch(options) {
+    const {
+      messages,
+      model = "llama-3.3-70b-versatile",
+      searchQuery,
+      maxResults = 5
+    } = options;
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+    const query = searchQuery || (typeof lastUserMessage?.content === "string" ? lastUserMessage.content : "");
+    const searchResults = await this.parent.getSearchProvider().search(query, { maxResults });
+    const context = searchResults.map((r, i) => `[${i + 1}] ${r.title}
+${r.snippet}
+URL: ${r.url}`).join("\n\n");
+    const systemPrompt = `You are a helpful assistant with access to web search results.
+Use the following search results to answer the question. Cite sources using [1], [2], etc.
+
+Search Results:
+${context}`;
+    const response = await this.parent.client.chat.completions.create({
+      model,
+      messages: [{ role: "system", content: systemPrompt }, ...messages]
+    });
+    return {
+      content: response.choices[0]?.message?.content || "",
+      sources: searchResults
+    };
+  }
+  /**
+   * Chat with URL content
+   */
+  async withUrl(options) {
+    const { messages, url, model = "llama-3.3-70b-versatile" } = options;
+    const fetchResult = await this.parent.getFetcher().fetch(url);
+    const systemPrompt = `You are a helpful assistant. Use the following web page content to answer questions.
+
+Title: ${fetchResult.title || "Unknown"}
+URL: ${url}
+
+Content:
+${fetchResult.markdown || fetchResult.content}`;
+    const response = await this.parent.client.chat.completions.create({
+      model,
+      messages: [{ role: "system", content: systemPrompt }, ...messages]
+    });
+    return {
+      content: response.choices[0]?.message?.content || "",
+      source: fetchResult
+    };
+  }
+};
+var WebModule = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Fetch a URL
+   */
+  async fetch(url, options) {
+    return this.parent.getFetcher().fetch(url, options);
+  }
+  /**
+   * Fetch multiple URLs
+   */
+  async fetchMany(urls, options) {
+    return this.parent.getFetcher().fetchMany(urls, options);
+  }
+  /**
+   * Search the web
+   */
+  async search(query, options) {
+    return this.parent.getSearchProvider().search(query, options);
+  }
+  /**
+   * Fetch URL and convert to markdown
+   */
+  async fetchMarkdown(url) {
+    return this.parent.getFetcher().fetchMarkdown(url);
+  }
+};
+var RAGModule = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Add a document to the knowledge base
+   */
+  async addDocument(content, metadata) {
+    const retriever = await this.parent.getRetriever();
+    return retriever.addDocument(content, metadata);
+  }
+  /**
+   * Add multiple documents
+   */
+  async addDocuments(documents) {
+    const retriever = await this.parent.getRetriever();
+    return retriever.addDocuments(documents);
+  }
+  /**
+   * Add a URL's content to the knowledge base
+   */
+  async addUrl(url, metadata) {
+    const fetcher = this.parent.getFetcher();
+    const result = await fetcher.fetch(url);
+    const content = result.markdown || result.content;
+    const retriever = await this.parent.getRetriever();
+    return retriever.addDocument(content, {
+      ...metadata,
+      url,
+      title: result.title,
+      fetchedAt: result.fetchedAt.toISOString()
+    });
+  }
+  /**
+   * Query the knowledge base
+   */
+  async query(query, options) {
+    const retriever = await this.parent.getRetriever();
+    return retriever.retrieve(query, options);
+  }
+  /**
+   * Get formatted context for a query
+   */
+  async getContext(query, options) {
+    const retriever = await this.parent.getRetriever();
+    return retriever.getContext(query, options);
+  }
+  /**
+   * Clear the knowledge base
+   */
+  async clear() {
+    const retriever = await this.parent.getRetriever();
+    return retriever.clear();
+  }
+  /**
+   * Get document count
+   */
+  async count() {
+    const retriever = await this.parent.getRetriever();
+    return retriever.count();
+  }
+};
+
+// src/index.ts
+var index_default = GroqRAG;
+export {
+  Agent,
+  BraveSearch,
+  ChromaVectorStore,
+  DuckDuckGoSearch,
+  GroqEmbeddings,
+  GroqRAG,
+  MemoryVectorStore,
+  OpenAIEmbeddings,
+  Retriever,
+  SerperSearch,
+  TextChunker,
+  ToolExecutor,
+  WebFetcher,
+  batch,
+  chunkText,
+  cleanText,
+  cosineSimilarity,
+  createAgent,
+  createCalculatorTool,
+  createDateTimeTool,
+  createEmbeddingProvider,
+  createFetchUrlTool,
+  createFetcher,
+  createRAGQueryTool,
+  createRetriever,
+  createSearchProvider,
+  createToolExecutor,
+  createVectorStore,
+  createWebSearchTool,
+  index_default as default,
+  estimateTokens,
+  extractUrls,
+  formatContext,
+  generateId,
+  getBuiltinTools,
+  retry,
+  safeJsonParse,
+  sleep,
+  truncateToTokens
+};