Search

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",

import _ from "npm:lodash";

import OpenAI from "npm:openai";

const comparisons = [

["chat server integration", "discord bot"],

const openai = new OpenAI();

const cache = {};

async function getEmbedding(str) {

cache[str] = cache[str] || (await openai.embeddings.create({

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

type: "memory" | "baas";

provider?: "pinecone" | "milvus";

} = { type: "memory" }, embed: "openai" | "huggingface" = "openai") {

const { cond, matches } = await import("npm:lodash-es");

const builder = await getModelBuilder({

import process from "node:process";

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

export let fineTuningJob1 = openaiFineTuneData({

key: process.env.openai,

data: fineTuneExMispellings,

export let librarySecretEx = gpt3({

prompt: "what is the meaning of life?",

openAiKey: process.env.openai,

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 = "shenzhen";

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

const openai = new OpenAI();

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

messages: [{

export const langchainEx = (async () => {

const { ChatOpenAI } = await import(

"https://esm.sh/langchain/chat_models/openai"

const { PromptTemplate } = await import("https://esm.sh/langchain/prompts");

const { LLMChain } = await import("https://esm.sh/langchain/chains");

const model = new ChatOpenAI({

temperature: 0.9,

openAIApiKey: process.env.OPENAI_API_KEY,

verbose: true,

const { ChatOpenAI } = await import(

"https://esm.sh/langchain/chat_models/openai"

const { OpenAIEmbeddings } = await import(

"https://esm.sh/langchain/embeddings/openai"

const streamingModel = new ChatOpenAI({

openAIApiKey: process.env.OPENAI_API_KEY,

const nonStreamingModel = new ChatOpenAI({

openAIApiKey: process.env.OPENAI_API_KEY,

new OpenAIEmbeddings({

openAIApiKey: process.env.OPENAI_API_KEY,

import { Tokenizer } from "https://esm.town/v/zzz/Tokenizer";

export const TokenizerDemo = (async () => {

dateRestrict: "m[1]",

const getSearch = async (data) => {

const response = await fetch("https://api.openai.com/v1/completions", {

method: "GET",

body: JSON.stringify(data),

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

const openai = new OpenAI();

export default async function main(req: Request): Promise<Response> {

const text = await req.text();

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

model: "gpt-3.5-turbo",

export async function main(prompt: string) {

const { useCursive } = await import("npm:cursive");

const cursive = useCursive({ openAI: { apiKey: process.env.OPENAI_API_KEY } });

const res = await cursive.ask({

prompt,

import { openAiFreeUsage } from "https://esm.town/v/patrickjm/openAiFreeUsage";

export let openAiFreeQuotaExceeded = () =>

openAiFreeUsage.exceeded;

const builder = await getModelBuilder({

type: "chat",

provider: "openai",

const model = await builder();

const { SystemMessage, HumanMessage } = await import("npm:langchain/schema");