Custom Hacker News summaries in your inbox—build an AI Agent with Inngest and Render

CREATE TABLE IF NOT EXISTS stories (
  id SERIAL PRIMARY KEY,
  title TEXT,
  content TEXT,
  date DATE,
  comments TEXT,
  interest_id INTEGER REFERENCES interests(id),
  embedding vector(1536)
);

-- Create an index on the embedding column for faster similarity searches
CREATE INDEX IF NOT EXISTS stories_embedding_idx ON stories 
USING hnsw (embedding vector_cosine_ops);

async function generateEmbedding(text: string): Promise<number[]> {
  const response = await openai.embeddings.create({
    model: "text-embedding-ada-002",
    input: text,
  });
  return response.data[0].embedding;
}

export async function storeStory(story: Story): Promise<void> {
  // [...]

  // Generate embedding from title and content
  const embedding = await generateEmbedding(`${story.title} ${story.content}`);

  // Insert new story into `stories` db table
  await client.query(
    "INSERT INTO stories (title, content, date, comments, embedding, interest_id) VALUES ($1, $2, $3::date, $4, $5::vector, $6)",
    [
      story.title,
      story.content,
      story.date,
      story.comments,
      `[${embedding.join(",")}]`,
      story.interest_id,
    ]
  );
}

import { inngest } from "./client";

export const hackerNewsAgent = inngest.createFunction(
  {
    id: "hacker-news-agent",
  },
  { event: "hacker-news-agent/run" },
  async ({ event, db, step }) => {
    const { interest_id, question_id } = event.data;

    // By wrapping code in step.run(),
    //   the code will be retried if it throws an error.
    // If successful, its result is saved to prevent unnecessary re-execution.
    const { interest, question } = await step.run(
      "fetch-interest-and-question",
      async () => {
        const interest = await db.query(
          "SELECT * FROM interests WHERE id = $1 LIMIT 1",
          [interest_id]
        );
        const question = await db.query(
          "SELECT * FROM questions WHERE id = $1 LIMIT 1",
          [question_id]
        );
        return { interest: interest.rows[0], question: question.rows[0] };
      }
    );

    if (!interest || !question) {
      console.warn(
        "[HackerNewsAgent] Interest or question not found, aborting"
      );
      return;
    }
  }
);

import {
  createAgent
} from "@inngest/agent-kit";

const summarizerAgent = createAgent({
      name: "Summarizer Agent",
      description: "Summarize the results of the search agent",
      system: ({ network }) => {
        const searchResults = network?.state.kv.get("search-result");
        const trendsResults = network?.state.kv.get("trends-result");
        const prompt = `
        Prepare the answers to the questions based on the results of the search agent.
        If the user is interested in trends, use the trends-result to answer the questions and provide a summary of the trends.
        If the user is not interested in trends, use the search-result to answer the questions.

        The user is interested in ${
          interest.name
        }. They asked the following questions: 
        <questions>
        ${question.question}
        </questions>

        The search agent found the following results online: 
        <search-results>
        ${(searchResults || []).join(`\n`)}
        </search-results>

        The trends agent found the following trends:
        <trends-results>
        ${(trendsResults || []).join(`\n`)}
        </trends-results>

        Provide you answer wrapped in <answer> tags.
        `;
        return prompt;
      },
      / ...
    });

import {
  createAgent,
  createTool,
} from "@inngest/agent-kit";


const searchAgent = createAgent({
  name: "Search Agent",
  description: "Search Hacker News for a given set of interests",
  system: `You are a search agent that searches Hacker News for posts that are relevant to a given set of interests. Today is ${
    new Date().toISOString().split("T")[0]
  }. Search for posts from the last ${frequencyToRelativeHuman(
    question.frequency
  )} period.`,
  tools: [
    createTool({
      name: "search",
      description: "Search Hacker News for a given set of interests",
      parameters: z.object({
        query: z.string(),
        startDate: z.string(),
        endDate: z.string(),
      }),
      handler: async (input, { network }) => {
        // ...
      },
    }),
    createTool({
      name: "identify-trends",
      description:
        "Identify trends on Hacker News for a given set of interests",
      parameters: z.object({
        query: z.string(),
        startDate: z.string(),
        endDate: z.string(),
      }),
      handler: async (input, { network }) => {
        // ...
      },
    }),
  ],
});

import {
  createAgent,
  createTool,
} from "@inngest/agent-kit";


const searchAgent = createAgent({
  name: "Search Agent",
  // ...
  tools: [
    // ...
    createTool({
      name: "identify-trends",
      description:
        "Identify trends on Hacker News for a given set of interests",
      parameters: z.object({
        query: z.string(),
        startDate: z.string(),
        endDate: z.string(),
      }),
      handler: async (input, { network }) => {
        console.info("[HackerNewsAgent] Identifying trends", input);
        // Generate embedding for the query
        const openai = new OpenAI({
          apiKey: process.env.OPENAI_API_KEY,
        });

        const embedding = await openai.embeddings.create({
          model: "text-embedding-ada-002",
          input: input.query,
        });

        // Find similar stories using vector similarity
        const similarStories = await db.query(
          `WITH similar_stories AS (
                SELECT title, content, date::timestamp as date, comments,
                  (embedding <=> $1::vector) as distance
                FROM stories
                WHERE (embedding <=> $1::vector) < 0.3
                AND interest_id = $2
                AND date >= $3::date
                AND date <= $4::date
                ORDER BY date DESC
              )
              SELECT 
                date_trunc('day', date) as story_date,
                COUNT(*) as story_count,
                STRING_AGG(title, ' | ' ORDER BY date DESC) as titles
              FROM similar_stories
              GROUP BY date_trunc('day', date)
              ORDER BY story_date DESC
              LIMIT 10`,
          [
            `[${embedding.data[0].embedding.join(",")}]`,
            interest.id,
            input.startDate,
            input.endDate,
          ]
        );

        // Format results to show trends
        const result = similarStories.rows.map((row) => {
          const date = new Date(row.story_date).toLocaleDateString();
          return `Date: ${date}\nNumber of Related Stories: ${row.story_count}\nTitles: ${row.titles}\n\n`;
        });

        console.info(
          "[HackerNewsAgent] Trends results:",
          input.query,
          result.length
        );

        network?.state.kv.set("trends-result", result);

        return result;
      },
    }),
  ],
});

import { openai } from "inngest";
import {
  createNetwork,
  getDefaultRoutingAgent,
} from "@inngest/agent-kit";


const model = openai({ model: "gpt-4" });
const network = createNetwork({
  agents: [searchAgent.withModel(model), summarizerAgent.withModel(model)],
  defaultModel: model,
  maxIter: 4,
  defaultRouter: ({ network }) => {
    if (network?.state.kv.has("answers")) {
      return;
    } else if (
      network?.state.kv.has("search-result") ||
      network?.state.kv.has("trends-result")
    ) {
      return summarizerAgent;
    }
    return getDefaultRoutingAgent();
  },
});

const result = await network.run(
  `I am passionate about ${interest.name}. Answer the following questions: ${question.question}`
);

if (result.state.kv.has("answers") && !event.data.preview) {
      await step.run("send-email", async () => {
        console.info("[HackerNewsAgent] Preparing to send email");
        const answers = result.state.kv.get("answers");

        if (!event.data.preview) {
          const { data, error } = await resend.emails.send({
            from: "Hacker News Agent <onboarding@resend.dev>",
            to: interest.email,
            subject: `Your Hacker News Agent Update on ${interest.name}`,
            text: `Here are the answers to "${question.question}":\n\n${answers}`,
          });

          // …