LLMs: Beyond Chat - JS/TS + Vercel AI SDK port

import { generateObject } from 'npm:ai';
import { openai } from 'npm:@ai-sdk/openai';
import { z } from 'npm:zod';
import dotenv from 'npm:dotenv';

let _ = dotenv.config();

const gpt4o = openai('gpt-4o');

function showTable(tableObject) {
  const tableHTML = `
    <table>
      <thead>
        <tr>
          ${Object.keys(tableObject[0]).map(column => `<th style="text-align: center">${column}</th>`).join('')}
        </tr>
      </thead>
      <tbody>
        ${tableObject.map(row => `
          <tr>
            ${Object.values(row).map(column => `<td style="text-align: left">${column}</td>`).join('')}
          </tr>
        `).join('')}
      </tbody>
    </table>
  `;
  //return await Deno.jupyter.display({ 'text/html': tableHTML }, { raw: true });
  return Deno.jupyter.html`${tableHTML}`;
}; 

const germanText = 'Sprachkenntnisse sind ein wichtiger Bestandteil der Kommunikation.';

const translation = await generateObject({
   model: gpt4o,
   schema: z.object({
    input_language: z.string().describe('The language of the original text, as 2-letter language code.'),
    translation: z.string(),
  }),
   system: '',
   prompt: germanText,
});

console.log(translation.object);

const englishText = 'Large Language Models are a powerful tool for natural language processing.';

const targetLanguages = ['de', 'fr', 'it', 'es', 'he'];

const translations = await generateObject({
  model: gpt4o,
  schema: z.object({
    translations: z.array(z.object({
      language: z.enum(targetLanguages).describe(
        'The target language for the translation, as 2-letter language code.'
      ),
      translation: z.string(),
    }))
  }),
  system: 'Translate the user-provided text into the following languages: ' +
    JSON.stringify(targetLanguages),
  prompt: englishText,
  temperature: 0.7,
});

showTable(translations.object.translations);

const inputText = 'Large Language Models are a powerful tool for natural language processing.';

const textStyles = ['formal', 'informal', 'casual', 'academic', 'professional', 'business'];

const normalizations = await generateObject({
  model: gpt4o,
  schema: z.object({
    normalizations: z.array(z.object({
      language: z.enum(textStyles).describe(
        'The style of the text normalization.'
      ),
      translation: z.string(),
    }))
  }),
  system: 'Normalize the user-provided text into the following styles: ' +
    JSON.stringify(textStyles),
  prompt: inputText,
  temperature: 0.7,
});

showTable(normalizations.object.normalizations);

const addressStr = (
  'Sherlock Holmes lives in the United Kingdom. ' +
  'His residence is in at 221B Baker Street, London, NW1 6XE.'
);

const addressInfo = await generateObject({
  model: gpt4o,
  schema: z.object({
    first_name: z.string(),
    last_name: z.string(),
    street: z.string(),
    house_number: z.string(),
    postal_code: z.string(),
    city: z.string(),
    state: z.string(),
    country: z.string(),
  }),
  prompt: addressStr,
});

console.log(addressInfo.object);

const addressesText = (
  'During my recent travels, I had the pleasure of visiting several fascinating locations. ' +
  'My journey began at the office of Dr. Elena Martinez, 142B Elm Street, San Francisco, ' +
  'CA 94107, USA. Her office, nestled in the bustling heart of the city, was a hub of ' +
  'innovation and creativity. Next, I made my way to the historic residence of Mr. Hans ' +
  'Gruber located at 3. Stock, Goethestrasse 22, 8001 Zürich, Switzerland. The old building, ' +
  'with its classic Swiss architecture, stood as a testament to the city’s rich cultural ' +
  'heritage. My adventure continued at the tranquil countryside home of Satoshi Nakamoto, ' +
  '2-15-5, Sakura-cho, Musashino-shi, Tokyo-to 180-0003, Japan. Their home was surrounded by ' +
  'beautiful cherry blossoms, creating a picturesque scene straight out of a postcard. In ' +
  'Europe, I visited the charming villa of Mme. Catherine Dubois, 15 Rue de la République, ' +
  '69002 Lyon, France. The cobblestone streets and historic buildings of Lyon provided a ' +
  'perfect backdrop to her elegant home. Finally, my journey concluded at the modern apartment ' +
  'of Mr. David Johnson, Apt 7B, 34 Queen Street, Toronto, ON M5H 2Y4, Canada. The sleek ' +
  'design of the apartment building mirrored the contemporary vibe of the city itself.'
)

const addresses = await generateObject({
  model: gpt4o,
  schema: z.object({
    addresses: z.array(z.object({
      first_name: z.string(),
      last_name: z.string(),
      street: z.string(),
      house_number: z.string(),
      postal_code: z.string(),
      city: z.string(),
      state: z.string(),
      country: z.string(),
    }))
  }),
  system: 'Return all the addresses in the user-provided text.',
  prompt: addressesText,
});

showTable(addresses.object.addresses);

const graphInputText = (
  'Some products are edible and others are inedible. Soap, newspapers, and shoes, for example, ' +
  'are inedible. Of the products that are edible, some are sweet and others are savory. ' +
  'Chocolate, candy, and ice cream are sweet, while pizza, burgers, and fries are savory. ' +
  'Chocolate comes in different forms, such as milk chocolate, dark chocolate, and white chocolate. ' +
  'The New York Times, The Wall Street Journal, and The Washington Post are newspapers.'
);

const graph = await generateObject({
  model: gpt4o,
  schema: z.object({
    nodes: z.array(z.object({
      id: z.number(),
      label: z.string(),
    })),
    edges: z.array(z.object({
      source: z.number(),
      target: z.number(),
    })),
  }),
  system: 'Format the information in the user-provided text as a knowledge graph.',
  prompt: graphInputText,
});

console.log(graph.object.nodes);
console.log(graph.object.edges);

const inputStr = 'the quick brown fox jumps over the lazy dog';

const NounPhrase = z.object({
  det: z.string(),
  adj: z.array(z.string()),
  noun: z.string(),
});

const PrepPhrase = z.object({
  prep: z.string(),
  noun: NounPhrase,
});

const VerbPhrase = z.object({
  noun: NounPhrase,
  verb: z.string(),
  prep: PrepPhrase,
});

const grammarTree = await generateObject({
  model: gpt4o,
  schema: VerbPhrase,
  system: 'Parse the user-provided sentence into a simple grammar tree.',
  prompt: inputStr,
});

console.log(JSON.stringify(grammarTree.object, null, 2));

const foodReview = await generateObject({
  model: gpt4o,
  schema: z.object({
    rating: z.number(),
    sentiment: z.string().describe('A review about food.'),
  }),
  prompt: 'Generate food review with sentiments within a spectrum of sentiments, with rating between 1 and 5.',
  temperature: 0.5,
});

console.log(foodReview.object);

const ratings = ['*', '**', '***', '****', '*****'];
const numReviews = 10;

const foodReviews = await generateObject({
  model: gpt4o,
  schema: z.object({
    reviews: z.array(z.object({
      rating: z.enum(ratings).describe('rating of food review between 1 and 5'),
      sentiment: z.string().describe('A generated review about food.'),
    }))
  }),
  prompt: (
    `Generate ${numReviews} food review with sentiments within a spectrum of sentiments in ` +
    `sorted order from most negative to positive, with rating: ` +
    `${JSON.stringify(ratings)}`
  ),
  temperature: 0.7,
});

showTable(foodReviews.object.reviews);

const exampleTexts = [
  'I am very happy with the service provided by the company.',
  'The food was terrible and the service was slow.',
  'The movie was okay.',
  'The weather is perfect for a day at the beach.',
  'I am mostly satisfied with the product, but there are a few issues.',
  'The experience was not quite what I have expected.',
  'Butterflies are often colourful, and they can fly.',
]

const sentiments = await Promise.all(exampleTexts.map(async (text) => {
  const response = await generateObject({
    model: gpt4o,
    schema: z.object({
      sentiment: z.string(),
      confidence: z.number(),
    }),
    system: 'Analyze the sentiment of the user-provided text.',
    prompt: text,
  });
  return response.object;
}));

showTable(sentiments.map((sentiment, idx) => {
  return {
    text: exampleTexts[idx],
    sentiment: sentiment.sentiment,
    confidence: sentiment.confidence,
  };
}));

const items = [
  {title: 'The Great Gatsby', subtitle: 'A novel by F. Scott Fitzgerald'},
  {title: 'The Theory of Relativity', subtitle: 'A scientific theory by Albert Einstein'},
  {title: 'The Technology and Culture of Ancient Rome', subtitle: 'A cross-disciplinary study of ancient Rome'},
  {title: 'Football on Television', subtitle: 'The technology and cultural impact of televising football games'},
  {title: 'The Philosophy of Taylor Swift', subtitle: 'A philosophical analysis of the music and lyrics of Taylor Swift'},
  {title: 'The Spanish Language in popular music', subtitle: 'A review of the use of the Spanish language in popular music'},
  {title: 'The Impact of Artificial Intelligence on Healthcare', subtitle: 'Exploring the role of AI in revolutionizing healthcare'},
  {title: 'The History of Jazz Music', subtitle: 'Tracing the origins and evolution of jazz music'},
  {title: 'The Rise of E-commerce in the Digital Age', subtitle: 'Examining the growth and impact of online shopping'},
  {title: 'The Art of Photography', subtitle: 'Exploring the creative and technical aspects of photography'},
  {title: 'The Psychology of Decision Making', subtitle: 'Understanding the cognitive processes behind decision making'},
  {title: 'The Role of Women in STEM Fields', subtitle: 'Highlighting the contributions of women in science, technology, engineering, and mathematics'},
  {title: 'The Cultural Significance of Tattoos', subtitle: 'Exploring the history and symbolism of tattoos in different cultures'},
];

const tags = [
  'literature', 'science', 'history', 'technology', 'art', 'music', 'sports',
  'philosophy', 'language', 'feminism', 'health', 'media', 'physics', 'culture',
  'psychology', 'artificial_intelligence',
];

const itemTags = await generateObject({
  model: gpt4o,
  schema: z.object({
    items: z.array(z.object({
      title: z.string(),
      subtitle: z.string(),
      tags: z.array(z.enum(tags)),
    }))
  }),
  system: `Tag the following items with the appropriate tags. Options: ${JSON.stringify(tags)}`,
  prompt: JSON.stringify(items),
});

showTable(itemTags.object.items.map((item) => {
  return {
    title: item.title,
    subtitle: item.subtitle,
    tags: item.tags.join(' '),
  };
}));

const numClusters = 5;

const taggedItemsClusters = await generateObject({
  model: gpt4o,
  schema: z.object({
    clusters: z.array(z.object({
      title: z.string().describe('The title of the cluster.'),
      items: z.array(z.string()).describe('The titles of the items in the cluster.'),
    }))
  }),
  system: `Cluster the following items based on their tags and content. Create exactly ${numClusters} clusters.`,
  prompt: JSON.stringify(itemTags.object.items),
});

const clustersTable = [];

for (const cluster of taggedItemsClusters.object.clusters) {
  for (const itemTitle of cluster.items) {
    const item = itemTags.object.items.find(i => i.title === itemTitle);
    if (item) {
      clustersTable.push({
        cluster: cluster.title,
        title: item.title,
        subtitle: item.subtitle,
        tags: item.tags.join(' '),
      });
    }
  }
}

showTable(clustersTable);

const actions = [
  'Wake up',
  'Turn off the alarm',
  'Stretch',
  'Get out of bed',
  'Use the bathroom',
  'Check for movie snacks',
  'Wash face in the evening',
  'Change into pyjamas',
  'Set alarm for the next day',
  'Check phone for messages',
  'Turn off lights',
  'Walk or drive to the movie theatre',
  'Use the bathroom in the evening',
  'Dry off with a towel',
  'Brush teeth',
  'Wash face',
  'Take a shower',
  'Grab wallet or purse',
  'Make sure phone is charged',
  'Call a taxi or arrange transportation',
  'Meet friends at designated place',
  'Leave the house',
  'Plan to buy tickets at the theatre',
  'Decide on meeting place and time',
  'Get dressed',
  'Apply deodorant',
  'Comb or brush hair',
  'Style hair',
  'Shave',
  'Put on clothes',
  'Apply makeup',
  'Prepare breakfast',
  'Eat breakfast',
  'Make coffee or tea',
  'Check phone for messages or emails',
  'Pack lunch',
  'Gather work materials',
  'Put on shoes',
  'Grab keys',
  'Purchase tickets at the theatre',
  'Lock the door',
  'Finish dinner',
  'Clean up dinner dishes',
  'Watch TV or read a book',
  'Brush teeth in the evening',
  'Get into bed',
  'Meditate or relax',
  'Write in journal',
  'Listen to calming music',
  'Turn off electronic devices',
  'Adjust pillows and blankets',
  'Read a book',
  'Close eyes and try to sleep',
  'Decide on a movie to watch',
  'Check movie times online',
  'Purchase tickets online',
  'Buy snacks at the concession stand',
  'Find the correct theatre screen',
  'Find seats',
  'Watch the movie',
  'Discuss the movie with friends',
  'Say goodbye to friends',
  'Return home',
];

const activities = [
  'Waking up and going to work',
  'Winding down and going to sleep',
  'Going to see a movie with friends',
];

for (const activity of activities) {
  const actionSequence = await generateObject({
    model: gpt4o,
    schema: z.object({
      actions: z.array(z.enum(actions)),
    }),
    system: 'Generate a sequence of actions for the user-provided activity.',
    prompt: activity,
  });

  console.log(`Activity: ${activity}`);
  actionSequence.object.actions.forEach((action, idx) => {
    console.log(`${idx + 1}. ${action}`);
  });
  console.log('\n');
}