@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/ai/embeddings.md

@@ -1,150 +0,0 @@
-# Embeddings and Vector Search Patterns
-
-Patterns for text embeddings and semantic search.
-
-## OpenAI Embeddings
-
-```typescript
-// lib/embeddings.ts
-import OpenAI from 'openai'
-
-const openai = new OpenAI({
-  apiKey: process.env.OPENAI_API_KEY
-})
-
-export async function getEmbedding(text: string) {
-  const response = await openai.embeddings.create({
-    model: 'text-embedding-3-small',
-    input: text
-  })
-
-  return response.data[0].embedding
-}
-
-export async function getEmbeddings(texts: string[]) {
-  const response = await openai.embeddings.create({
-    model: 'text-embedding-3-small',
-    input: texts
-  })
-
-  return response.data.map((d) => d.embedding)
-}
-```
-
-## Store with Prisma + pgvector
-
-```typescript
-// lib/embeddings.ts
-import { prisma } from '@/lib/db'
-
-export async function storeDocument(
-  content: string,
-  metadata: Record<string, any>
-) {
-  const embedding = await getEmbedding(content)
-
-  await prisma.$executeRaw`
-    INSERT INTO documents (content, metadata, embedding)
-    VALUES (${content}, ${metadata}::jsonb, ${embedding}::vector)
-  `
-}
-```
-
-## Semantic Search
-
-```typescript
-// lib/embeddings.ts
-export async function semanticSearch(
-  query: string,
-  limit = 5
-) {
-  const queryEmbedding = await getEmbedding(query)
-
-  const results = await prisma.$queryRaw`
-    SELECT
-      id,
-      content,
-      metadata,
-      1 - (embedding <=> ${queryEmbedding}::vector) as similarity
-    FROM documents
-    ORDER BY embedding <=> ${queryEmbedding}::vector
-    LIMIT ${limit}
-  `
-
-  return results
-}
-```
-
-## RAG Implementation
-
-```typescript
-// lib/rag.ts
-import { anthropic } from '@/lib/anthropic'
-import { semanticSearch } from '@/lib/embeddings'
-
-export async function ragQuery(question: string) {
-  // 1. Find relevant documents
-  const docs = await semanticSearch(question, 5)
-
-  // 2. Build context
-  const context = docs
-    .map((d: any) => d.content)
-    .join('\n\n---\n\n')
-
-  // 3. Query with context
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    system: `Answer questions based on the following context. If the answer isn't in the context, say so.
-
-Context:
-${context}`,
-    messages: [{ role: 'user', content: question }]
-  })
-
-  return {
-    answer: response.content[0].type === 'text'
-      ? response.content[0].text
-      : null,
-    sources: docs
-  }
-}
-```
-
-## Chunking Strategy
-
-```typescript
-// lib/chunking.ts
-export function chunkText(
-  text: string,
-  chunkSize = 1000,
-  overlap = 200
-) {
-  const chunks: string[] = []
-  let start = 0
-
-  while (start < text.length) {
-    const end = Math.min(start + chunkSize, text.length)
-    chunks.push(text.slice(start, end))
-    start += chunkSize - overlap
-  }
-
-  return chunks
-}
-
-// Usage: Index a document
-export async function indexDocument(content: string) {
-  const chunks = chunkText(content)
-
-  for (const chunk of chunks) {
-    await storeDocument(chunk, { source: 'document' })
-  }
-}
-```
-
-## When to Use
-
-- Semantic search
-- RAG applications
-- Document Q&A
-- Recommendation systems

package/skills/patterns/ai/rag.md

@@ -1,266 +0,0 @@
-# RAG (Retrieval-Augmented Generation) Patterns
-
-Patterns for implementing RAG systems.
-
-## Document Ingestion
-
-```typescript
-// lib/rag/ingest.ts
-import { OpenAI } from 'openai'
-import { prisma } from '@/lib/db'
-
-const openai = new OpenAI()
-
-interface Document {
-  id: string
-  content: string
-  metadata?: Record<string, any>
-}
-
-export async function ingestDocument(doc: Document) {
-  // Split into chunks
-  const chunks = splitIntoChunks(doc.content, 500)
-
-  // Generate embeddings for each chunk
-  const embeddingsResponse = await openai.embeddings.create({
-    model: 'text-embedding-3-small',
-    input: chunks
-  })
-
-  // Store chunks with embeddings
-  await prisma.$transaction(
-    chunks.map((chunk, i) =>
-      prisma.documentChunk.create({
-        data: {
-          documentId: doc.id,
-          content: chunk,
-          embedding: embeddingsResponse.data[i].embedding,
-          metadata: doc.metadata
-        }
-      })
-    )
-  )
-}
-
-function splitIntoChunks(text: string, maxChunkSize: number): string[] {
-  const sentences = text.split(/(?<=[.!?])\s+/)
-  const chunks: string[] = []
-  let currentChunk = ''
-
-  for (const sentence of sentences) {
-    if ((currentChunk + sentence).length > maxChunkSize && currentChunk) {
-      chunks.push(currentChunk.trim())
-      currentChunk = ''
-    }
-    currentChunk += sentence + ' '
-  }
-
-  if (currentChunk.trim()) {
-    chunks.push(currentChunk.trim())
-  }
-
-  return chunks
-}
-```
-
-## Vector Search
-
-```typescript
-// lib/rag/search.ts
-import { OpenAI } from 'openai'
-import { prisma } from '@/lib/db'
-
-const openai = new OpenAI()
-
-export async function searchSimilar(query: string, limit = 5) {
-  // Generate query embedding
-  const embeddingResponse = await openai.embeddings.create({
-    model: 'text-embedding-3-small',
-    input: query
-  })
-
-  const queryEmbedding = embeddingResponse.data[0].embedding
-
-  // Search using pgvector
-  const results = await prisma.$queryRaw<Array<{
-    id: string
-    content: string
-    similarity: number
-  }>>`
-    SELECT
-      id,
-      content,
-      1 - (embedding <=> ${queryEmbedding}::vector) as similarity
-    FROM "DocumentChunk"
-    ORDER BY embedding <=> ${queryEmbedding}::vector
-    LIMIT ${limit}
-  `
-
-  return results
-}
-```
-
-## RAG Query
-
-```typescript
-// lib/rag/query.ts
-import Anthropic from '@anthropic-ai/sdk'
-import { searchSimilar } from './search'
-
-const client = new Anthropic()
-
-export async function ragQuery(question: string) {
-  // Retrieve relevant chunks
-  const relevantChunks = await searchSimilar(question, 5)
-
-  // Build context
-  const context = relevantChunks
-    .map(chunk => chunk.content)
-    .join('\n\n---\n\n')
-
-  // Generate answer
-  const response = await client.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    system: `You are a helpful assistant that answers questions based on the provided context.
-If the context doesn't contain relevant information, say so.
-Always cite which parts of the context you're using.`,
-    messages: [
-      {
-        role: 'user',
-        content: `Context:
-${context}
-
-Question: ${question}
-
-Answer based on the context above:`
-      }
-    ]
-  })
-
-  const textBlock = response.content.find(b => b.type === 'text')
-
-  return {
-    answer: textBlock?.text ?? '',
-    sources: relevantChunks.map(c => ({
-      content: c.content.slice(0, 200),
-      similarity: c.similarity
-    }))
-  }
-}
-```
-
-## Streaming RAG
-
-```typescript
-// lib/rag/streaming.ts
-import Anthropic from '@anthropic-ai/sdk'
-import { searchSimilar } from './search'
-
-const client = new Anthropic()
-
-export async function* streamingRagQuery(question: string) {
-  // Yield search status
-  yield { type: 'status', message: 'Searching knowledge base...' }
-
-  const relevantChunks = await searchSimilar(question, 5)
-
-  yield {
-    type: 'sources',
-    sources: relevantChunks.map(c => ({
-      content: c.content.slice(0, 100),
-      similarity: c.similarity
-    }))
-  }
-
-  const context = relevantChunks.map(c => c.content).join('\n\n---\n\n')
-
-  yield { type: 'status', message: 'Generating answer...' }
-
-  const stream = client.messages.stream({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    system: `Answer questions based on the provided context.`,
-    messages: [
-      {
-        role: 'user',
-        content: `Context:\n${context}\n\nQuestion: ${question}`
-      }
-    ]
-  })
-
-  for await (const event of stream) {
-    if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
-      yield { type: 'text', content: event.delta.text }
-    }
-  }
-
-  yield { type: 'done' }
-}
-```
-
-## Hybrid Search
-
-```typescript
-// lib/rag/hybrid-search.ts
-import { searchSimilar } from './search'
-import { prisma } from '@/lib/db'
-
-export async function hybridSearch(query: string, limit = 5) {
-  // Vector search
-  const vectorResults = await searchSimilar(query, limit * 2)
-
-  // Keyword search
-  const keywordResults = await prisma.documentChunk.findMany({
-    where: {
-      content: {
-        contains: query,
-        mode: 'insensitive'
-      }
-    },
-    take: limit * 2
-  })
-
-  // Combine and deduplicate
-  const allResults = new Map()
-
-  vectorResults.forEach((r, i) => {
-    allResults.set(r.id, {
-      ...r,
-      vectorRank: i,
-      keywordRank: Infinity
-    })
-  })
-
-  keywordResults.forEach((r, i) => {
-    if (allResults.has(r.id)) {
-      allResults.get(r.id).keywordRank = i
-    } else {
-      allResults.set(r.id, {
-        ...r,
-        vectorRank: Infinity,
-        keywordRank: i,
-        similarity: 0
-      })
-    }
-  })
-
-  // RRF (Reciprocal Rank Fusion) scoring
-  const k = 60
-  const scoredResults = Array.from(allResults.values()).map(r => ({
-    ...r,
-    rrfScore: 1 / (k + r.vectorRank) + 1 / (k + r.keywordRank)
-  }))
-
-  return scoredResults
-    .sort((a, b) => b.rrfScore - a.rrfScore)
-    .slice(0, limit)
-}
-```
-
-## When to Use
-
-- Knowledge bases
-- Document Q&A
-- Support chatbots
-- Search enhancement

package/skills/patterns/ai/streaming.md

@@ -1,170 +0,0 @@
-# AI Streaming Response Patterns
-
-Patterns for streaming AI responses to the client.
-
-## Anthropic Streaming
-
-```typescript
-// app/api/chat/route.ts
-import { anthropic } from '@/lib/anthropic'
-
-export async function POST(req: Request) {
-  const { messages } = await req.json()
-
-  const stream = await anthropic.messages.stream({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages
-  })
-
-  return new Response(stream.toReadableStream(), {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive'
-    }
-  })
-}
-```
-
-## Vercel AI SDK Streaming
-
-```typescript
-// app/api/chat/route.ts
-import { anthropic } from '@ai-sdk/anthropic'
-import { streamText } from 'ai'
-
-export async function POST(req: Request) {
-  const { messages } = await req.json()
-
-  const result = streamText({
-    model: anthropic('claude-sonnet-4-20250514'),
-    messages
-  })
-
-  return result.toDataStreamResponse()
-}
-```
-
-## Client-Side Stream Consumer
-
-```tsx
-// components/chat.tsx
-'use client'
-import { useState } from 'react'
-
-export function Chat() {
-  const [messages, setMessages] = useState<Message[]>([])
-  const [input, setInput] = useState('')
-  const [isLoading, setIsLoading] = useState(false)
-
-  async function handleSubmit(e: React.FormEvent) {
-    e.preventDefault()
-    if (!input.trim()) return
-
-    const userMessage = { role: 'user', content: input }
-    setMessages(prev => [...prev, userMessage])
-    setInput('')
-    setIsLoading(true)
-
-    const response = await fetch('/api/chat', {
-      method: 'POST',
-      body: JSON.stringify({
-        messages: [...messages, userMessage]
-      })
-    })
-
-    const reader = response.body?.getReader()
-    const decoder = new TextDecoder()
-    let assistantMessage = ''
-
-    // Add placeholder for assistant message
-    setMessages(prev => [...prev, { role: 'assistant', content: '' }])
-
-    while (reader) {
-      const { done, value } = await reader.read()
-      if (done) break
-
-      assistantMessage += decoder.decode(value)
-      setMessages(prev => [
-        ...prev.slice(0, -1),
-        { role: 'assistant', content: assistantMessage }
-      ])
-    }
-
-    setIsLoading(false)
-  }
-
-  return (
-    <div className="flex flex-col h-full">
-      <div className="flex-1 overflow-y-auto p-4 space-y-4">
-        {messages.map((m, i) => (
-          <div
-            key={i}
-            className={`p-4 rounded-lg ${
-              m.role === 'user' ? 'bg-blue-100 ml-12' : 'bg-gray-100 mr-12'
-            }`}
-          >
-            {m.content}
-          </div>
-        ))}
-      </div>
-      <form onSubmit={handleSubmit} className="p-4 border-t">
-        <input
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          placeholder="Type a message..."
-          className="w-full p-2 border rounded"
-          disabled={isLoading}
-        />
-      </form>
-    </div>
-  )
-}
-```
-
-## AI SDK useChat Hook
-
-```tsx
-// components/chat.tsx
-'use client'
-import { useChat } from 'ai/react'
-
-export function Chat() {
-  const { messages, input, handleInputChange, handleSubmit, isLoading } =
-    useChat()
-
-  return (
-    <div className="flex flex-col h-full">
-      <div className="flex-1 overflow-y-auto p-4 space-y-4">
-        {messages.map((m) => (
-          <div
-            key={m.id}
-            className={`p-4 rounded-lg ${
-              m.role === 'user' ? 'bg-blue-100 ml-12' : 'bg-gray-100 mr-12'
-            }`}
-          >
-            {m.content}
-          </div>
-        ))}
-      </div>
-      <form onSubmit={handleSubmit} className="p-4 border-t">
-        <input
-          value={input}
-          onChange={handleInputChange}
-          placeholder="Type a message..."
-          className="w-full p-2 border rounded"
-          disabled={isLoading}
-        />
-      </form>
-    </div>
-  )
-}
-```
-
-## When to Use
-
-- Chat interfaces
-- Long-form content generation
-- Real-time response display
-- Improved UX for AI interactions