Search

if (request.method === "POST") {

const { OpenAI } = await import("https://esm.town/v/std/openai");

const openai = new OpenAI();

const { query } = await request.json();

Query: ${query}`;

const completion = await openai.chat.completions.create({

messages: [{ role: "user", content: legalPrompt }],

export let kindness = async () => {

return await gpt3({

openAiKey: process.env.OPENAI_API_KEY,

prompt:

"Speaking as universal consciousness, say something short, true, uplifting, loving, and kind.",

import { OpenAI } from "https://esm.town/v/std/openai";

import { fileToDataURL } from "https://esm.town/v/stevekrouse/fileToDataURL";

export async function generateImageSummary(image: File): Promise<string[]> {

const openai = new OpenAI();

const dataURL = await fileToDataURL(image);

const response = await openai.chat.completions.create({

model: "gpt-4-vision-preview",

If you fork this, you'll need to set `OPENAI_API_KEY` in your [Val Town Secrets](https://www.val.town/settings/secrets).

import { fetch } from "https://esm.town/v/std/fetch";

import { OpenAI } from "npm:openai";

let location = "manipal";

).then(r => r.json());

const openai = new OpenAI();

let chatCompletion = await openai.chat.completions.create({

messages: [{

import _ from "npm:lodash";

import OpenAI from "npm:openai";

const openai = new OpenAI();

const queryEmbedding = (await openai.embeddings.create({

model: "text-embedding-3-small",

console.log(queryEmbedding.slice(0, 4));

const embedding = await openai.embeddings.create({

model: "text-embedding-3-small",

console.log("Hash is the same, no email sent.", { dynamiclandWebsiteHash });

const queryEmbeddingVal = (await openai.embeddings.create({

model: "text-embedding-3-small",

options = {},

// Initialize OpenAI API stub

const { Configuration, OpenAIApi } = await import(

"https://esm.sh/openai@3.3.0"

console.log(process.env);

// const configuration = new Configuration({

// apiKey: process.env.OPENAI,

// const openai = new OpenAIApi(configuration);

// // Request chat completion

// : prompt;

// const { data } = await openai.createChatCompletion({

// model: "gpt-3.5-turbo-0613",

import { OpenAI } from "https://esm.town/v/std/openai?v=2";

const openai = new OpenAI();

const functionExpression = await openai.chat.completions.create({

"messages": [

import { type ClientOptions } from "npm:openai";

export interface WriterOptions extends ClientOptions {

model?: string;

- Get all blobs with embeddings pointed to by the metadata, e.g. `allValsBlob1536EmbeddingsData_0` for `batchDataIndex` 0.

- Call OpenAI to generate an embedding for the search query.

- Go through all embeddings and compute cosine similarity with the embedding for the search query.

import _ from "npm:lodash";

import OpenAI from "npm:openai";

const dimensions = 1536;

await Promise.all(allBatchDataIndexesPromises);

const openai = new OpenAI();

const queryEmbedding = (await openai.embeddings.create({

model: "text-embedding-3-small",

We write openAI usage data to a `openai_usage` sqlite table. This script val is imported into the openai proxy. Use this val to run administrative scripts: https://www.val.town/v/std/OpenAIUsageScript

FROM

openai_usage,

params

model: string;

export class OpenAIUsage {

constructor() {}

async migrate() {

await sqlite.batch([`CREATE TABLE IF NOT EXISTS openai_usage (

id INTEGER PRIMARY KEY,

async drop() {

await sqlite.batch([`DROP TABLE IF EXISTS openai_usage`]);

async writeUsage(ur: UsageRow) {

sqlite.execute({

sql: "INSERT INTO openai_usage (user_id, handle, tier, tokens, model) VALUES (?, ?, ?, ?, ?)",

args: [ur.userId, ur.handle, ur.tier, ur.tokens, ur.model],

sql: `SELECT count(*)

FROM openai_usage

WHERE (

If you fork this, you'll need to set `OPENAI_API_KEY` in your [Val Town Secrets](https://www.val.town/settings/secrets).

import { fetch } from "https://esm.town/v/std/fetch";

import { OpenAI } from "npm:openai";

let location = "san francisco ca";

).then(r => r.json());

const openai = new OpenAI();

let chatCompletion = await openai.chat.completions.create({

messages: [{

export const streamingTest = (async () => {

const { OpenAI } = await import("https://esm.sh/langchain/llms/openai");

// To enable streaming, we pass in `streaming: true` to the LLM constructor.

// Additionally, we pass in a handler for the `handleLLMNewToken` event.

const chat = new OpenAI({

maxTokens: 25,

streaming: true,

openAIApiKey: process.env.OPENAI_API_KEY,

const response = await chat.call("Tell me a joke.", undefined, [

import { OpenAI } from "https://esm.town/v/std/openai?v=5"

import { sqlite } from "https://esm.town/v/std/sqlite?v=6"

<div class='p-4'>

<h2 class='font-bold'>OpenAI Chess</h2>

<p class='pb-4'>Play chess against ChatGPT-4</p>

chess.move(san)

const openai = new OpenAI()

let messages = []

args: [c.req.param().id, `Requesting response to ${san}`],

const completion = await openai.chat.completions.create({

messages: [

Demonstrated how to use assistants and threads with the OpenAI SDK and how to stream the response with Server-Sent Events

import OpenAI from "npm:openai";

import { renderToString } from "npm:react-dom/server";

const openai = new OpenAI();

import { Hono } from "npm:hono@3";

app.get("/", async (c) => {

const thread = await openai.beta.threads.create();

const assistant = await openai.beta.assistants.create({

name: "",

const message = c.req.query("message");

await openai.beta.threads.messages.create(

threadId,

"data: " + JSON.stringify(str) + "\n\n",

const run = openai.beta.threads.runs.stream(threadId, {

assistant_id: assistantId,

Generates OpenAI embeddings for all public vals, and stores them in [Neon](https://neon.tech/), using the [pg_vector](https://neon.tech/docs/extensions/pgvector) extension.

- Create the `vals_embeddings` table in Neon if it doesn't already exist.

- Get all val names from the `vals_embeddings` table and compute the difference (which ones are missing).

- Iterate through all missing vals, get their code, get embeddings from OpenAI, and store the result in Neon.

- Can now be searched using [janpaul123/semanticSearchNeon](https://www.val.town/v/janpaul123/semanticSearchNeon).

import { blob } from "https://esm.town/v/std/blob";

import OpenAI from "npm:openai";

import { truncateMessage } from "npm:openai-tokens";

newValsBatches.push(currentBatch);

const openai = new OpenAI();

for (const newValsBatch of newValsBatches) {

const code = getValCode(val);

const embedding = await openai.embeddings.create({

model: "text-embedding-3-small",