npm install ai @ai-sdk/openai @ai-sdk/anthropic

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { text, usage } = await generateText({
  model: openai('gpt-4o'),
  prompt: 'Explique TypeScript para iniciantes em 3 parágrafos',
});

console.log(text);
console.log(`Tokens: ${usage.promptTokens} → ${usage.completionTokens}`);

import { generateObject } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { z } from 'zod';

const schema = z.object({
  title: z.string(),
  summary: z.string(),
  tags: z.array(z.string()),
  difficulty: z.enum(['iniciante', 'intermediário', 'avançado']),
});

const { object } = await generateObject({
  model: anthropic('claude-sonnet-4-20250514'),
  schema,
  prompt: 'Analise este artigo sobre TypeScript Clean Code',
});

// object é tipado como { title: string; summary: string; tags: string[]; difficulty: ... }
console.log(object.title);
console.log(object.difficulty);

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai('gpt-4o'),
    messages,
  });

  return result.toDataStreamResponse();
}

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const result = await generateText({
  model: openai('gpt-4o'),
  prompt: 'Qual a temperatura em São Paulo?',
  tools: {
    getWeather: {
      description: 'Obtém a temperatura atual de uma cidade',
      parameters: z.object({
        city: z.string().describe('Nome da cidade'),
        unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
      }),
      execute: async ({ city, unit }) => {
        const temp = await fetchWeather(city);
        return unit === 'celsius' ? `${temp}°C` : `${(temp * 9/5 + 32).toFixed(1)}°F`;
      },
    },
  },
});

import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const agent = generateText({
  model: openai('gpt-4o'),
  maxSteps: 5, // permite múltiplos passos de tool calling
  tools: {
    search: tool({
      description: 'Busca informações na web',
      parameters: z.object({ query: z.string() }),
      execute: async ({ query }) => webSearch(query),
    }),
    summarize: tool({
      description: 'Resume um texto',
      parameters: z.object({ text: z.string() }),
      execute: async ({ text }) => summarize(text),
    }),
  },
  prompt: 'Pesquise sobre TypeScript 7.0 e me dê um resumo',
});

npm install @anthropic-ai/sdk

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic(); // usa ANTHROPIC_API_KEY do env

const message = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Explique discriminated unions' }],
});

console.log(message.content[0].text);

const stream = client.messages.stream({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Escreva um artigo sobre TypeScript' }],
});

for await (const event of stream) {
  if (event.type === 'content_block_delta') {
    process.stdout.write(event.delta.text);
  }
}

import OpenAI from 'openai';

const openai = new OpenAI();

const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'TypeScript ou JavaScript?' }],
  stream: true,
});

for await (const chunk of completion) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

import { z } from 'zod';

// Schema reutilizável para validação de saída da IA
const AnalysisSchema = z.object({
  sentiment: z.enum(['positive', 'negative', 'neutral']),
  confidence: z.number().min(0).max(1),
  topics: z.array(z.string()).max(5),
  summary: z.string().max(200),
});

type Analysis = z.infer<typeof AnalysisSchema>;
// { sentiment: 'positive' | 'negative' | 'neutral'; confidence: number; ... }

# /llms.txt
## Kaique Yamamoto — Portfolio

Stack: Next.js 16, TypeScript, Tailwind CSS v4, Fumadocs

### Convenções
- Sempre usar `import type` para tipos
- strictNullChecks obrigatório
- Componentes em PascalCase
- Links internos: <Link> do Next.js, nunca <a>

// Os coding assistants geram testes type-safe automaticamente
import { describe, it, expect } from 'vitest';
import { parseJson } from './utils';

describe('parseJson', () => {
  it('retorna ok:true com JSON válido', () => {
    const result = parseJson<User>('{"name":"Kaique"}');
    expect(result.ok).toBe(true);
    if (result.ok) {
      expect(result.value.name).toBe('Kaique');
    }
  });

  it('retorna ok:false com JSON inválido', () => {
    const result = parseJson<User>('not json');
    expect(result.ok).toBe(false);
  });
});

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

const server = new McpServer({ name: 'my-server', version: '1.0.0' });

server.tool(
  'get_weather',
  'Obtém a temperatura atual',
  { city: z.string() },
  async ({ city }) => {
    const temp = await fetchWeather(city);
    return { content: [{ type: 'text', text: `${city}: ${temp}°C` }] };
  },
);