“I Added AI to My Project in 2 Hours — Here’s the Exact Code”

What people think "AI development" is:
😱 Training massive models on GPUs
😱 Understanding backpropagation
😱 Writing Python ML code
😱 Needing a PhD

What it actually is for 99% of dev work:
✅ fetch() to an AI API endpoint
✅ Send text in, get text back
✅ Same as calling a weather API
✅ Learnable in 2 hours 😄

npm install openai
# that's it. one package. 📦

# .env.local (Next.js) or .env (React)
OPENAI_API_KEY=sk-your-key-here

# ⚠️ CRITICAL: Add to .gitignore immediately
# Never commit API keys to GitHub — ever 🔒

# .gitignore — make sure this is there
.env.local
.env
.env.production

// app/api/explain/route.js

import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY  // server-side only 🔒
})

export async function POST(request) {
  try {
    const { text, level } = await request.json()

    // Basic validation — always do this ✅
    if (!text || text.trim().length === 0) {
      return Response.json(
        { error: 'No text provided' }, 
        { status: 400 }
      )
    }

    if (text.length > 5000) {
      return Response.json(
        { error: 'Text too long. Max 5000 characters.' },
        { status: 400 }
      )
    }

    // The AI call 🤖
    const completion = await openai.chat.completions.create({
      model: 'gpt-4o-mini', // cheaper, still great for this task 💰
      messages: [
        {
          role: 'system',
          content: `You are an expert at explaining complex things simply.
                    Explain at this level: ${level || 'beginner'}.
                    Use simple words. Use examples. Be concise.
                    Format with clear paragraphs. No bullet points.`
        },
        {
          role: 'user',
          content: `Explain this simply:\n\n${text}`
        }
      ],
      max_tokens: 500,
      temperature: 0.7  // 0 = robotic, 1 = creative, 0.7 = balanced 🎚️
    })

    const explanation = completion.choices[0].message.content

    return Response.json({ explanation })

  } catch (error) {
    console.error('AI API error:', error)
    return Response.json(
      { error: 'Something went wrong. Try again.' },
      { status: 500 }
    )
  }
}

// components/TextExplainer.tsx
'use client'

import { useState } from 'react'

export default function TextExplainer() {
  const [input, setInput]           = useState('')
  const [explanation, setExplanation] = useState('')
  const [loading, setLoading]       = useState(false)
  const [error, setError]           = useState('')

  const handleExplain = async () => {
    if (!input.trim()) return

    setLoading(true)
    setError('')
    setExplanation('')

    try {
      const res = await fetch('/api/explain', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ text: input, level: 'beginner' })
      })

      const data = await res.json()

      if (!res.ok) {
        setError(data.error || 'Something went wrong')
        return
      }

      setExplanation(data.explanation)

    } catch (err) {
      setError('Network error. Check your connection.')
    } finally {
      setLoading(false) // always runs — success or fail ✅
    }
  }

  return (
    <div className="max-w-2xl mx-auto p-6 space-y-4">
      <h1 className="text-2xl font-bold">🧠 AI Text Explainer</h1>

      <textarea
        value={input}
        onChange={(e) => setInput(e.target.value)}
        placeholder="Paste any confusing text here..."
        className="w-full h-40 p-3 border rounded-lg resize-none"
        maxLength={5000}
      />

      <div className="flex justify-between items-center">
        <span className="text-sm text-gray-400">
          {input.length}/5000 characters
        </span>
        <button
          onClick={handleExplain}
          disabled={loading || !input.trim()}
          className="px-6 py-2 bg-blue-600 text-white rounded-lg 
                     disabled:opacity-50 disabled:cursor-not-allowed
                     hover:bg-blue-700 transition-colors"
        >
          {loading ? '🤔 Thinking...' : '✨ Explain This'}
        </button>
      </div>

      {/* Error state */}
      {error && (
        <div className="p-4 bg-red-50 border border-red-200 rounded-lg text-red-700">
          ❌ {error}
        </div>
      )}

      {/* Result */}
      {explanation && (
        <div className="p-4 bg-blue-50 border border-blue-200 rounded-lg">
          <h2 className="font-semibold mb-2">✅ Here's the simple version:</h2>
          <p className="text-gray-700 leading-relaxed">{explanation}</p>
        </div>
      )}
    </div>
  )
}

// app/api/stream/route.js

import OpenAI from 'openai'

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

export async function POST(request) {
  const { prompt } = await request.json()

  // Create a streaming completion 🌊
  const stream = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    stream: true,  // ← this one word changes everything ✨
    messages: [
      { role: 'system', content: 'You are a helpful assistant.' },
      { role: 'user', content: prompt }
    ]
  })

  // Stream the response back chunk by chunk 📦
  const readableStream = new ReadableStream({
    async start(controller) {
      const encoder = new TextEncoder()

      for await (const chunk of stream) {
        const text = chunk.choices[0]?.delta?.content || ''
        if (text) {
          controller.enqueue(encoder.encode(text))
        }
      }
      controller.close()
    }
  })

  return new Response(readableStream, {
    headers: {
      'Content-Type': 'text/plain; charset=utf-8',
      'Transfer-Encoding': 'chunked',
    }
  })
}

// The streaming magic on the client side ✨
'use client'

import { useState } from 'react'

export default function StreamingChat() {
  const [prompt, setPrompt]   = useState('')
  const [response, setResponse] = useState('')
  const [loading, setLoading] = useState(false)

  const handleStream = async () => {
    setLoading(true)
    setResponse('') // clear previous

    const res = await fetch('/api/stream', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ prompt })
    })

    // Read the stream chunk by chunk 🌊
    const reader = res.body.getReader()
    const decoder = new TextDecoder()

    while (true) {
      const { done, value } = await reader.read()
      if (done) break

      const text = decoder.decode(value)
      setResponse(prev => prev + text) // append each chunk 🎯
    }

    setLoading(false)
  }

  return (
    <div className="max-w-2xl mx-auto p-6 space-y-4">
      <h1 className="text-2xl font-bold">⚡ Streaming AI</h1>

      <textarea
        value={prompt}
        onChange={e => setPrompt(e.target.value)}
        placeholder="Ask anything..."
        className="w-full h-32 p-3 border rounded-lg"
      />

      <button
        onClick={handleStream}
        disabled={loading || !prompt.trim()}
        className="w-full py-3 bg-purple-600 text-white rounded-lg
                   disabled:opacity-50 hover:bg-purple-700"
      >
        {loading ? '⚡ Streaming...' : '🚀 Generate'}
      </button>

      {/* Response appears word by word — like ChatGPT! 🤩 */}
      {response && (
        <div className="p-4 bg-gray-50 rounded-lg whitespace-pre-wrap
                        font-mono text-sm leading-relaxed">
          {response}
          {loading && <span className="animate-pulse">▊</span>}
        </div>
      )}
    </div>
  )
}

// The key insight — send the full conversation history each time 📚
'use client'

import { useState } from 'react'

// Message type
type Message = {
  role: 'user' | 'assistant'
  content: string
}

export default function ChatWithMemory() {
  const [messages, setMessages] = useState<Message[]>([])
  const [input, setInput]       = useState('')
  const [loading, setLoading]   = useState(false)

  const sendMessage = async () => {
    if (!input.trim()) return

    const userMessage: Message = { role: 'user', content: input }
    const updatedMessages = [...messages, userMessage]

    setMessages(updatedMessages)
    setInput('')
    setLoading(true)

    try {
      const res = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ messages: updatedMessages }) // send ALL history 🗂️
      })

      const data = await res.json()
      const aiMessage: Message = { 
        role: 'assistant', 
        content: data.reply 
      }

      setMessages(prev => [...prev, aiMessage])
    } finally {
      setLoading(false)
    }
  }

  // Handle Enter key 🎹
  const handleKeyDown = (e: React.KeyboardEvent) => {
    if (e.key === 'Enter' && !e.shiftKey) {
      e.preventDefault()
      sendMessage()
    }
  }

  return (
    <div className="max-w-2xl mx-auto p-6 flex flex-col h-screen">
      <h1 className="text-2xl font-bold mb-4">🧠 AI Chat with Memory</h1>

      {/* Message history */}
      <div className="flex-1 overflow-y-auto space-y-3 mb-4">
        {messages.map((msg, i) => (
          <div
            key={i}
            className={`p-3 rounded-lg max-w-[80%] ${
              msg.role === 'user'
                ? 'bg-blue-600 text-white ml-auto'      // right side 👤
                : 'bg-gray-100 text-gray-800 mr-auto'   // left side 🤖
            }`}
          >
            {msg.content}
          </div>
        ))}
        {loading && (
          <div className="bg-gray-100 p-3 rounded-lg max-w-[80%] mr-auto">
            <span className="animate-pulse">🤖 thinking...</span>
          </div>
        )}
      </div>

      {/* Input area */}
      <div className="flex gap-2">
        <textarea
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyDown={handleKeyDown}
          placeholder="Type a message... (Enter to send)"
          className="flex-1 p-3 border rounded-lg resize-none h-14"
          rows={1}
        />
        <button
          onClick={sendMessage}
          disabled={loading || !input.trim()}
          className="px-4 bg-blue-600 text-white rounded-lg
                     disabled:opacity-50 hover:bg-blue-700"
        >
          Send 🚀
        </button>
      </div>
    </div>
  )
}

// app/api/chat/route.js — handles full conversation history
export async function POST(request) {
  const { messages } = await request.json()

  const completion = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: 'You are a helpful, friendly assistant. Keep responses concise.'
      },
      ...messages  // ← spread the full history here 🗂️
    ],
    max_tokens: 500
  })

  return Response.json({
    reply: completion.choices[0].message.content
  })
}

// ❌ NEVER DO THIS — exposes key to everyone
const openai = new OpenAI({
  apiKey: 'sk-real-key-here',  // visible in browser devtools 😱
  dangerouslyAllowBrowser: true
})

// ✅ Always call AI from API routes (server-side) 🔒
// Key stays on server. Users never see it.

// ❌ Without rate limiting — one angry user can drain your credits fast
// ✅ Simple rate limiting with upstash or even just in-memory:

const requestCounts = new Map()

export async function POST(request) {
  const ip = request.headers.get('x-forwarded-for') || 'unknown'
  const count = requestCounts.get(ip) || 0

  if (count > 10) { // max 10 requests per session
    return Response.json(
      { error: 'Too many requests. Slow down! 😅' },
      { status: 429 }
    )
  }

  requestCounts.set(ip, count + 1)
  // ... rest of handler
}

// ❌ Without loading state — user clicks button, nothing happens, clicks again
// Result: 5 duplicate API calls 💸

// ✅ Always disable button during loading
<button
  onClick={handleSubmit}
  disabled={loading}  // ← this one prop saves you money 💰
>
  {loading ? 'Thinking...' : 'Submit'}
</button>

// ❌ Vague — AI doesn't know what you want
{ role: 'system', content: 'Be helpful.' }

// ✅ Specific — AI knows exactly what to do
{ role: 'system', content: `You are a code reviewer for React/TypeScript.
  Review code for: bugs, performance issues, and best practices.
  Format: score out of 10, then bullet points of specific feedback.
  Be direct. Be specific. Always explain WHY.` }

gpt-4o-mini pricing (most affordable, still great):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Input:   $0.150 per 1M tokens
Output:  $0.600 per 1M tokens

Real world costs:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1 average explanation request ≈ $0.0003
1000 requests ≈ $0.30 (thirty paise per 1000!) 😄
Portfolio project with 200 demo uses ≈ $0.06
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Free tier credit covers hundreds of demo uses 🆓

Hour 1 — Setup + First Feature
├── 0:00 Get API key + install SDK (10 min)
├── 0:10 Build the API route (20 min)
├── 0:30 Build the frontend component (25 min)
└── 0:55 Test it works locally (5 min)

Hour 2 — Polish + Deploy
├── 1:00 Add error handling (15 min)
├── 1:15 Add loading states (10 min)
├── 1:25 Clean up the UI (15 min)
└── 1:40 Deploy on Vercel (20 min)
    └── 2:00 Share the live link 🎉