User Question
    ↓
1. Convert question to embedding (OpenAI)
    ↓
2. Query Pinecone for similar vectors
    ↓
3. Retrieve relevant knowledge base chunks
    ↓
4. Send chunks + question to GPT-4
    ↓
5. Generate natural response
    ↓
User receives answer

# Ragamuffin Knowledge Base - Rockwell Windsor Rice ## Professional Profile Name: Rockwell Windsor Rice Title: Senior Software Engineer Experience: 10+ years ## Technical Expertise - Ruby on Rails (10+ years) - Next.js, React (4+ years) - AWS, GCP infrastructure ...

import { Pinecone } from '@pinecone-database/pinecone';

const pinecone = new Pinecone({
  apiKey: process.env.PINECONE_API_KEY,
});

// Create index with 1536 dimensions (matches OpenAI embeddings)
await pinecone.createIndex({
  name: 'chatbot-knowledge-base',
  dimension: 1536,
  metric: 'cosine',
  spec: {
    serverless: {
      cloud: 'aws',
      region: 'us-east-1'
    }
  }
});

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Split knowledge base into chunks
function chunkText(text, maxChunkSize = 500) {
  const chunks = [];
  const sections = text.split('\n## '); // Split by headers
  
  sections.forEach(section => {
    if (section.length <= maxChunkSize) {
      chunks.push(section);
    } else {
      // Further split large sections
      const sentences = section.split('. ');
      let currentChunk = '';
      
      sentences.forEach(sentence => {
        if ((currentChunk + sentence).length <= maxChunkSize) {
          currentChunk += sentence + '. ';
        } else {
          chunks.push(currentChunk.trim());
          currentChunk = sentence + '. ';
        }
      });
      
      if (currentChunk) chunks.push(currentChunk.trim());
    }
  });
  
  return chunks;
}

// Generate embeddings for each chunk
async function embedChunks(chunks) {
  const embeddings = [];
  
  for (const chunk of chunks) {
    const response = await openai.embeddings.create({
      model: 'text-embedding-ada-002',
      input: chunk,
    });
    
    embeddings.push({
      id: `chunk-${embeddings.length}`,
      values: response.data[0].embedding,
      metadata: { text: chunk }
    });
  }
  
  return embeddings;
}

async function uploadToPinecone(embeddings) {
  const index = pinecone.index('chatbot-knowledge-base');
  
  // Upload in batches (Pinecone recommends batch sizes of 100)
  const batchSize = 100;
  for (let i = 0; i < embeddings.length; i += batchSize) {
    const batch = embeddings.slice(i, i + batchSize);
    await index.upsert(batch);
  }
  
  console.log(`Uploaded ${embeddings.length} vectors to Pinecone`);
}

// pages/api/chat.js
export default async function handler(req, res) {
  const { question } = req.body;
  
  try {
    // 1. Convert question to embedding
    const questionEmbedding = await openai.embeddings.create({
      model: 'text-embedding-ada-002',
      input: question,
    });
    
    // 2. Query Pinecone for similar vectors
    const index = pinecone.index('chatbot-knowledge-base');
    const queryResponse = await index.query({
      vector: questionEmbedding.data[0].embedding,
      topK: 5, // Get top 5 most relevant chunks
      includeMetadata: true,
    });
    
    // 3. Extract relevant context
    const context = queryResponse.matches
      .map(match => match.metadata.text)
      .join('\n\n');
    
    // 4. Generate response with GPT-4
    const completion = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'system',
          content: `You are a helpful assistant representing Rockwell Windsor Rice, a senior software engineer. Answer questions based on the following context:\n\n${context}`
        },
        {
          role: 'user',
          content: question
        }
      ],
      temperature: 0.7,
      max_tokens: 500,
    });
    
    res.status(200).json({
      answer: completion.choices[0].message.content,
    });
    
  } catch (error) {
    console.error('Chat error:', error);
    res.status(500).json({ error: 'Failed to process question' });
  }
}

// components/ChatBot.jsx
import { useState } from 'react';

export default function ChatBot() {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');
  const [loading, setLoading] = useState(false);
  
  const handleSubmit = async (e) => {
    e.preventDefault();
    if (!input.trim()) return;
    
    // Add user message
    const userMessage = { role: 'user', content: input };
    setMessages(prev => [...prev, userMessage]);
    setInput('');
    setLoading(true);
    
    try {
      // Call API
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ question: input }),
      });
      
      const data = await response.json();
      
      // Add assistant response
      const assistantMessage = { role: 'assistant', content: data.answer };
      setMessages(prev => [...prev, assistantMessage]);
      
    } catch (error) {
      console.error('Error:', error);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    <div className="chat-container">
      <div className="messages">
        {messages.map((msg, idx) => (
          <div key={idx} className={`message ${msg.role}`}>
            {msg.content}
          </div>
        ))}
        {loading && <div className="loading">Thinking...</div>}
      </div>
      
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="Ask me anything about Rockwell's experience..."
        />
        <button type="submit">Send</button>
      </form>
    </div>
  );
}

// Delete old index
await pinecone.deleteIndex('chatbot-knowledge-base');

// Recreate with correct dimensions
await pinecone.createIndex({
  name: 'chatbot-knowledge-base',
  dimension: 1536, // Must match embedding model!
  metric: 'cosine',
});