Search

"resources": "resources",

const typesenseClient = new Typesense.Client({

"nodes": [{

// console.log("Search params:", searchParams); // Add this line

let resources = await typesenseClient

.collections(COLLECTIONS.resources)

searchParams.filter_by = "";

resources = await typesenseClient.collections(COLLECTIONS.resources).documents().search(searchParams);

const resourcesWithDistance = resources.hits?.map((hit) => {

Use GPT to return JIT personalization for client side applications.

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

simple wrapper for [Alchemy's blockchain APIs](https://docs.alchemy.com/reference/alchemy-gettokenbalances), for fetching blockchain data. Ethereum, Solana, etc

uses my personal ALCHEMY_API_KEY, I forget if you can use it too or not! get your own if it doesn't work

used by some of my other vals:

- https://www.val.town/v/jamiedubs/nftMetadata

- etc

type TokenParam = "erc20" | "nft" | string;

export async function alchemyFetch(path: string, tokens: TokenParam = "erc20") {

const apiKey = process.env.ALCHEMY_API_KEY;

if (!apiKey) throw new Error("missing ALCHEMY_API_KEY");

const baseUrl = tokens == "nft" ? "https://eth-mainnet.g.alchemy.com/nft/v2" : "https://eth-mainnet.g.alchemy.com/v2";

import { Slot } from "https://esm.sh/@radix-ui/react-slot";

import { cva, type VariantProps } from "https://esm.sh/class-variance-authority";

import * as React from "https://esm.sh/react";

import { cn } from "https://esm.town/v/nbbaier/shadcnUtils";

export interface ButtonProps

extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {

asChild?: boolean;

const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(

({ className, variant, size, asChild = false, ...props }, ref) => {

import { generateLessonHtml } from "https://esm.town/v/petermillspaugh/lessonTemplate";

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

* Note: this lesson is a work in progress 👷‍♂️

const TITLE = "Interleaving";

await import("npm:dotenv");

const { PineconeClient } = await import(

"npm:@pinecone-database/pinecone"

const client = new PineconeClient();

await client.init({

apiKey: process.env.PINECONE,

environment: "asia-southeast1-gcp-free",

const pineconeIndex = client.Index("langchain-valtown");

const { PineconeStore } = await import(

"npm:langchain/vectorstores/pinecone"

// PineconeStore.fromDocuments() gives out PineClient upsert error

return await PineconeStore.fromExistingIndex(model, {

import moment from "https://esm.sh/moment";

import { createClient } from "npm:@supabase/supabase-js";

class ForbetEventService {

_supabase;

constructor() {

this._supabase = createClient(

Deno.env.get("SUPABASE_URL"),

Deno.env.get("SUPABASE_ANON_KEY"),

1. Fork the val

2. From your ValTown settings page, add an environment variable named `bookmarks_client_id` and give it a value (you will be using this for saving)

3. Add another environment variable named `bookmarks_client_secret` and give it a value (you will also be using this for saving)

4. At first, the "bookmarks" table will not exist, so we need to save an article first, which will create the "bookmarks" table

5. To do this, add a bookmarklet to your browser with this value (replace `BOOKMARKS-CLIENT-ID` and `BOOKMARKS-CLIENT-SECRET` with the values you added to the environment variables, and replace `BOOKMARKS-URL` with your VAL's URL):

javascript:void(open('BOOKMARKS-URL/save?u='+encodeURIComponent(location.href)+'&t='+encodeURIComponent(document.title)+'&id=BOOKMARKS-CLIENT-ID&secret=BOOKMARKS-CLIENT-SECRET', 'Bookmark a link', 'width=400,height=450'))

6. Click this bookmarklet to bookmark the URL of the current active tab

Make sure you don't share `bookmarks_client_id` and `bookmarks_client_secret`. It is used for authentication before saving a bookmark.

return c.text("Authentication details (ID/Secret) missing!");

if (id != Deno.env.get("bookmarks_client_id") || secret != Deno.env.get("bookmarks_client_secret")) {

return c.text("Unauthorized!");

import { lessons } from "https://esm.town/v/petermillspaugh/lessons";

import { email as sendEmail } from "https://esm.town/v/std/email?v=11";

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

export async function sendLessonResponses({ email, lesson, formData }) {

const fillBlankResponse = formData.get("fill-in-the-blank") as string;

This val is a helper for Townie, which sends client-side

errors up to the top frame so that Townie can assist you in fixing them.

import process from "node:process";

import { Client } from "npm:@notionhq/client";

import dayjs from "npm:dayjs";

const DATABASE_ID = "519446a0d3ed47038fffd669b9ece770";

const notion = new Client({ auth: process.env.NOTION_API_KEY });

const intervalMapping = {

"Weekly": (date) => dayjs(date).add(1, "week"),

import { createAudioResource, createAudioPlayer, joinVoiceChannel, VoiceConnectionStatus } from '@discordjs/voice';

import { Client, GatewayIntentBits } from 'discord.js';

import googleTTS from 'google-tts-api';

const starting_amount = 5;

const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates] });

const pendingSimonSays = new Map();

client.on('voiceStateUpdate', async (oldState, newState) => {

const userId = newState.id;

client.login(process.env.DISCORD_BOT_TOKEN);

if (!bank) {

import moment from "npm:moment";

import { createClient } from "npm:@supabase/supabase-js";

class CacheService {

_supabase;

constructor() {

this._supabase = createClient(

Deno.env.get("SUPABASE_URL"),

Deno.env.get("SUPABASE_ANON_KEY")

3. The GET URL should be called and result printed in the console.

I'm using React, so make it a react component.

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

export interface WriterOptions extends ClientOptions {

model?: string;