# Git push, get an AI API.

Ryan Fox-Tyler, Hypermode

AI Engineer World's Fair 2024

[Talk page](https://ai.engineer/talks/R7xlYs5p0yA-git-push-get-ai-api) · [Video](https://www.youtube.com/watch?v=R7xlYs5p0yA)

## Git push, get an AI API

A category game leads into GitHub issue triage, showing how ordinary functions, typed model calls and shared embedding logic become a deployed API.

Basic familiarity with Git, typed functions and HTTP APIs is helpful; following the workshop's local build steps requires Node.js 20 or newer, Git and a text editor.

### How do you judge a roomful of category answers?

[0:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=0s)

How do you turn a familiar category game into something an entire workshop can play? The development approach is incremental: start with a working game, examine its building blocks, then reuse them for GitHub issue triage. Ryan Fox-Tyler introduces a newly launched Hypermode platform with room for things to break. Pushing directly to `main` is a time-saving workshop shortcut. Public issues provide accessible data for techniques that could also work on customer or product records.

**Hyper Categories** adapts Scattergories for a larger group. Fox-Tyler describes the traditional format as awkward beyond six or eight players. Each player supplies an answer matching a category and starting letter. A valid answer earns one point, shared among players who give similar answers. For furniture beginning with T, choosing `table` means sharing credit with everyone else who chooses it. The incentive is to be correct and unusual.

![Hypercategories rules slide showing the starting-letter prompt and scoring instructions.](https://ai.engineer/api/talk-essay-media/73beb182e0831de18e24d2155b96e6dfc962b51151ff8ea8eac13fefc0536e88)

Hypercategories rules: unique category answers earn points, with matching answers sharing the point.

The live round uses T. Participants join by QR code or the workshop link, with a Hypermode jacket offered to the winner. The displayed countdown does not automatically close submissions; the presenters allow extra time. A bot competes too, though its tendency to choose obvious answers works against the game's reward for originality.

### Filtering before similarity scoring

[5:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=300s)

Kirk Byers and Francisco tie for first, while the bot finishes fourth. Inspecting individual answers reveals a more useful result than the leaderboard: `Tevas` has been marked invalid for things you wear. The entrant still wins, but the judgment exposes a weakness in the model-assisted evaluation. The game is available as a deployable template, making its judging pipeline something developers can inspect and change.

![Game results list tevas as an invalid response with score zero, followed by other category answers and their scores.](https://ai.engineer/api/talk-essay-media/620c190f1ec238e33063366496989a0a93f0247a6881bda9a179ec4737fca3ac)

The game marks “A thing you wear: tevas” invalid.

The pipeline first validates the starting letter and uses a model to check category membership. During development, an occupation beginning with P exposed another failure: the model accepted `P doctor`. Adding a dictionary check supplied a constraint that the category model had not reliably enforced. **Useful AI behavior comes from combining model judgments with ordinary programmatic checks.**

Only after filtering does the game score answers. Similarity clustering treats `table` and `tables` as the same answer, so a plural does not evade shared credit. Exact string matching would miss that relationship. The scored results then feed the leaderboard.

Underneath are functions, a collection of user responses, models that support individual functions, and embedding models that support similarity search across the collection. Connections reach other Hypermode components, databases, conventional APIs and model hosts. Those pieces separate the game's rules from its model calls and data access, allowing one part to change without rebuilding the whole application.

### Deploying the issue-triage starter

[7:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=463s)

GitHub issues present a related sorting problem: contributors submit reports of uneven quality, and maintainers need to identify issue types, discover similar reports and understand repository-wide trends. The workshop develops those capabilities separately. Its original instructions are reached through the workshop short link or the AI World's Fair tab in Hypermode's documentation. Local prerequisites are a text editor, Node.js 20 or newer, Git and a way to clone a repository; VS Code and GitHub Desktop are presenter preferences.

The historical setup begins with the GitHub issue triage template in Just Ship AI. Selecting Deploy connects a GitHub account. An audience member reports that selecting one existing repository fails and that the permission screen appears to require access to all current and future repositories. The presenters say only the relevant repository should need access and describe the wording as confusing, but the reported failure is not resolved onstage. They offer follow-up inspection and the option to watch without proceeding.

Choose a personal account or organization, a repository name, and public or private visibility. The resulting repository is cloned from the issue-triage template; most workshop work lives in `functions/`. Clone that repository locally, enter the directory and install its dependencies:

```sh
cd functions
npm install
```

If VS Code still shows red diagnostics, open a TypeScript file and restart its TypeScript language server. The presenter attributes this behavior to an editor issue rather than a failed dependency installation.

![VS Code shows classify.ts, the project file tree, and terminal output reporting completed npm installation and zero vulnerabilities.](https://ai.engineer/api/talk-essay-media/afa6bbbc765f31bb11f5c75a261225c7112fe1370c45cbb2aba61466022285fb)

The cloned project in VS Code after dependency installation.

There are two template-creation paths:

| Entry point | Additional setup |
|---|---|
| Just Ship AI Deploy | Automates repository creation, Hypermode application installation and organization setup |
| GitHub Use this template | Requires importing the resulting project into Hypermode afterward |

Viewing the repository on GitHub merely opens the template; it does not perform the deployment setup.

Build from `functions/`:

```sh
npm run build
```

The build reports two exported functions, `classifyIssue` and `trendSummary`. The presenter expects Yarn, Bun and pnpm to work as well, but uses npm throughout. Although the source files end in `.ts`, the language is [AssemblyScript](https://www.assemblyscript.org/introduction.html), which compiles to WebAssembly. Familiar syntax and package tooling do not make arbitrary JavaScript or TypeScript dependencies compatible. The workshop uses WebAssembly as its execution boundary, with security and performance given as motivations; other language support is future work at this point in the recording.

### From retrieved issues to a trend prompt

[16:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=998s)

`trendSummary` begins with an OpenAI chat-model interface and system and user message objects. Its retrieval helper is conventional application code: it calls the [GitHub Issues REST API](https://docs.github.com/en/rest/issues/issues), substitutes request parameters, supplies headers and can log its progress. Hypermode's secrets mechanism supplies the GitHub token without placing it in source code. The helper returns an array of issue objects.

That array becomes the model's context. The function constructs text containing issue timestamps, user handles and titles, then asks for repository trends rather than a separate summary of every issue. The OpenAI model is referred to as **GPT-4.0** in the narration, without an exact API model identifier. The important operation is the transformation from retrieved records into a bounded request for analysis.

The same prompt-building step can be expressed as an AssemblyScript helper:

```typescript
class IssueContext {
  constructor(
    public createdAt: string,
    public userHandle: string,
    public title: string
  ) {}
}

function buildTrendContext(issues: IssueContext[]): string {
  const lines = new Array<string>();
  for (let i = 0; i < issues.length; i++) {
    const issue = issues[i];
    lines.push(
      issue.createdAt + " | " +
      issue.userHandle + " | " + issue.title
    );
  }
  return lines.join("\n");
}
```

The instruction belongs in the system message; the assembled issue context supplies the user message. Keeping construction in a helper makes the fields and formatting easy to change as the summarization behavior is refined.

Hypermode's typed model interface exposes the provider's request structure in the editor. `createInput` accepts messages, while completion suggestions reveal controls such as temperature, top-p, log probabilities, the number of choices and parallel tool calls. Type errors can fail compilation. An unsupported interface can be implemented by inheriting from a base class, rather than waiting for a built-in adapter.

Fox-Tyler calls this basic retrieval-augmented generation: fetch data, then ask a model to summarize it. Typed interfaces make experimentation easier, but they preserve model-specific controls because models differ in prompts, outputs, hyperparameters and API behavior. **A common programming workflow does not make models semantically interchangeable.**

The response path is equally ordinary: select the first choice, extract its message content and trim the string. That value could then be logged, stored in a database or passed into another model. The comparison to LangChain arises here, but the demonstrated composition requires only normal function calls and data transformations.

### Export a function, get a GraphQL endpoint

[21:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1318s)

The starter is already deployed, but newly written functions follow the title's workflow: commit and push, and Hypermode picks up the change for rollout. For `trendSummary`, the host configuration contains both an OpenAI API key and a GitHub token. The console's query tab provides GraphiQL for calling the deployed function.

After initially considering Hugging Face Transformers, the presenter chooses the .NET runtime repository without having tested that example beforehand. He reports that the live call fetches the top 100 issues from the .NET runtime repository and returns a trend summary within a few seconds. This is a summary of the retrieved issue set, not evidence that the entire repository has been analyzed.

No GraphQL schema was written for the function. Hypermode generates it from the exported function and its declared inputs. The resulting endpoint can be called through the console, Postman, another GraphQL client, `curl` or an HTTP client in an application. The exported function signature becomes the API contract.

An audience question makes the type boundary explicit. The workshop version infers GraphQL types, including supported custom scalars, and permits structured output objects. Inputs are restricted to scalars or arrays; structured input objects still require engineering work. Definitions can live in imported files or reusable AssemblyScript libraries distributed through npm. Those limits describe the demonstrated platform rather than a promise about later APIs.

### Inspecting what actually ran

[25:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1512s)

After a query, inference history exposes each model invocation's input, output and duration. This matters when a frontend dynamically builds prompts or a function chains several models: the final response alone does not explain what each call received. Token usage also remains available in history even when application code discards that part of the provider response.

Function Runs adds application and system logs grouped by individual execution. When calls overlap, that grouping lets a developer inspect one invocation without mixing its messages with another's. The displayed run history includes an expanded `trendSummary` execution and its logs.

![Hypermode Function Runs page with status indicators, durations, and an expanded trendSummary run showing log messages.](https://ai.engineer/api/talk-essay-media/a5af1a947b43af134310d46932cb1a607698e79c17de4e3e4bf885394c18ddec)

Function Runs displays execution history and expanded logs.

Deployment history links Git hashes back to source changes, connecting runtime behavior to the code that produced it. The presenters then leave the externally hosted summarizer as an optional exercise: attendees would otherwise need to supply OpenAI and GitHub credentials. The next function uses a model hosted inside Hypermode.

### Classifying issues with a small model

[27:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1636s)

`classifyIssue` does not fetch anything from GitHub. It accepts an issue ID, title and description, logs information about the request, and concatenates the title and description into model input. That formatting is a starting point to adjust for the chosen model. AssemblyScript's familiar syntax helps, although its type requirements can surface where ordinary TypeScript would be more permissive.

The presenter introduces **DistilBERT MNLI GitHub Issues**, a small, community-contributed Hugging Face model described as already trained for this task. The intended categories include bugs, feature requests and questions, so no training step is needed during the workshop. The imported classification interface comes from the models library's experimental area; the presenter describes it as matching many contemporary Hugging Face classification models.

Classification input is an array of strings, allowing several issues to be handled in one model call. Outputs correspond to those inputs. The demonstration submits one issue and therefore reads prediction zero; a batch would retain the matching predictions for all submitted strings. This differs from the chat model's message-and-choice interface while keeping the familiar sequence of creating input, invoking a model and consuming output.

Running the example exposes a transport problem before a modeling problem. The documentation query contains a complete GitHub issue, including text that needs escaped quotes and newlines. Copying it into the console produces malformed input. The presenter switches to a known-working query and suggests shortening the description for anyone blocked by the copied example. The full issue description remains the intended input; repairing the documentation is left for later. A classification result appears, but its exact label is not stated aloud.

The hosting difference is substantial:

| Function | Model execution | Application input |
|---|---|---|
| `trendSummary` | External OpenAI service | Retrieved issue context |
| `classifyIssue` | Dedicated Hypermode model instance | Supplied title and description |

Deploying the project automatically provisions the small classifier for that project. It can subsequently be customized, while the function continues to use a typed model interface.

The planned confidence-threshold extension is skipped because of time. It would compare a returned confidence score with an application-chosen threshold, without retraining the model. A small AssemblyScript helper captures that policy boundary:

```typescript
function acceptedLabel(
  label: string,
  confidence: f32,
  threshold: f32
): string | null {
  if (confidence < threshold) {
    return null;
  }
  return label;
}
```

Here, `null` lets the caller handle an unaccepted prediction. No threshold is selected or tested in the live exercise, and confidence alone does not establish label accuracy. Participants can continue modifying their running projects afterward.

### Declaring a collection and its embedder

[33:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1982s)

The next feature looks for related issues. A proposed bot could respond to a newly opened report with three existing issues that sound similar. The workshop builds the search API underlying that interaction, beginning with storage and indexing.

A **collection** provides an in-memory key-value store to which Hypermode can apply an index. The presenters distinguish this facility from a general database. In the root `hypermode.json` manifest, the existing model and host declarations gain a collection declaration. The visible configuration names `issuesCollection`, a `byTitle` search method and `miniLmEmbedder` as its embedding function.

![VS Code displays hypermode.json with issuesCollection, a byTitle search method, and miniLmEmbedder as its embedder.](https://ai.engineer/api/talk-essay-media/b127cb44c70be6a751ec9a085cd866dc1ec16f9b09081915335da89ce63a04f2)

The manifest declares an issues collection with a title search method and embedding function.

Vector search also needs a model that turns text into comparable vectors. The workshop adds **MiniLM** from Sentence Transformers, sourced from Hugging Face and hosted on Hypermode. The exact variant is not identified. The presenter commits the collection and model declarations, authenticates the signed commit and pushes before finishing the functions. That early push lets provisioning begin while coding continues; it is a scheduling choice, not a required separate deployment.

Next comes `embedder.ts`, using an embeddings-model interface. Its output is an array of vectors represented as `f32[][]`: each inner array contains 32-bit floating-point values. The function returns all predictions. It must also be exported through the module's index file; creating a source file alone does not expose it in the built module. Running `npm run build` inside `functions/` confirms that the embedder appears in the output. Raw vectors are now available, but they do not yet constitute a usable search feature.

### Returning useful search results

[37:21](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2241s)

The search function goes into a new file and is exported from the index as well. It imports the collections interface and defines a `SimilarIssue` class for structured results. Returning an array of those objects exercises the structured-output support discussed earlier: the build generates the corresponding GraphQL output type.

The function searches the manifest-configured collection and requests the top three results, including their text. Returning text suits this demonstration because the caller wants to inspect the matches immediately. An application that will fetch authoritative records from a database could instead request IDs and avoid transferring large text fields unnecessarily.

The presenter commits and pushes the search functions, then remembers to check the local build. Compilation reports the custom `SimilarIssue` type. At recording time, local compilation is available but local function execution is not; execution happens after deployment. In the console, both pushes have appeared, and the project now shows its issues collection, four functions and the added embedding model.

To populate the collection, the presenter downloads `issues.csv`, linked from the workshop documentation and described as containing previously scraped Transformers issues, then uploads it through the console. This is a convenient seed operation. The same ingestion could be driven by a function accepting API input or fetching issues from GitHub.

The collection configuration connects ingestion to indexing:

1. Add a record through code or file upload.
2. Hypermode invokes the configured embedding function for the new content.
3. The resulting vector becomes available for similarity search.
4. A search uses that same embedding function for its query text.

**Stored content and queries must be embedded consistently.** Here, both paths use the configured function, keeping the model choice aligned. Embedding runs in the background, so the upload and its inference-history entries do not necessarily become visible at the same instant.

### Nearest neighbors are not confirmed duplicates

[41:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2487s)

The first attempt to inspect embedding history does not show the expected records. The presenters try a search while suspecting that ingestion is still queued; initially, it appears to return nothing. The test input is a proposed issue asking to add a Spanish version of the README. In the imagined application, a bot would use this request to check whether someone had already asked for it.

Once the upload has finished, results mention a Turkish README, a French version and other language-related work. The presenter does not see a Spanish README duplicate. These are the most similar available records, which is a narrower conclusion than declaring the new issue redundant. A top-k search returns neighbors even when none is an exact match; the application still needs a policy for interpreting them. No bot comment is posted during this demonstration.

The missing inference records then appear. The presenter estimates that ingestion was split into batches of about 25 items and observes roughly two seconds for one batch and one second for another. Those are observations from the live run, with no hardware or repeatability comparison supplied. Expanding the history reveals the floating-point arrays: the embeddings that the search operation uses. The delayed visibility resolves during the demo, after the search itself has already produced useful results.

### Applying the functions to other data

[43:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2591s)

The workshop closes with room to continue in the documentation or with help after the session. HTTP calls and collection operations are available in the demonstrated platform; connections to arbitrary Postgres databases are explicitly described as forthcoming, not available yet. That boundary matters when deciding where authoritative data will live and how a function will retrieve it.

The closing slide broadens the same operations beyond GitHub: find similar issues, cases, patients, entities or products; classify type, urgency, propensity, quality or value; filter spam, duplicates, off-topic material, toxicity or outliers. Each application needs its own rules and evaluation, but the integration pattern is recognizable: put retrieval and validation in functions, call a suitable model, and expose a result another application can use.

![Slide with three groups: Find Similar lists issues, cases, patients, entities and products; Classify lists type, urgency, propensity, quality and value; Filter lists spam, duplicates, off-topic, toxicity and outliers.](https://ai.engineer/api/talk-essay-media/40aa6ed1fe0327f428021b008c41f5deb7152ee4fde1a14812cb8b21bae6ae05)

“What’s Next?” groups applications into finding similar items, classification, and filtering.

Just Ship AI templates are offered as starting points rather than requiring participants to begin from an empty repository. At the workshop, attendees receive a fourteen-day Hypermode trial and are invited to reply to their email to claim credits mentioned earlier that day. The presenters also offer help adapting the setup to a team's own context. The practical next iteration is to replace the public issue data with the records and decisions that matter to that application.

## Resources

- [AssemblyScript introduction](https://www.assemblyscript.org/introduction.html) — Explains compilation to WebAssembly, differences from TypeScript, and package compatibility.
- [GitHub Issues REST API](https://docs.github.com/en/rest/issues/issues) — Reference for retrieving repository issues, including pagination, filtering, authentication and pull-request handling.
- [GitHub issue classifier model card](https://huggingface.co/AntoineMC/distilbart-mnli-github-issues) — Documents a distilled classifier for issues, feature requests and questions, including its training approach and inference examples.
- [all-MiniLM-L6-v2 embeddings](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) — A sentence-embedding model with examples for generating vectors and measuring semantic similarity.
- [Modus source archive](https://github.com/hypermodeinc/modus) — Hypermode's WebAssembly framework with generated APIs, Go and AssemblyScript support, and local development instructions. Archived September 11, 2025.

## Slides

### Presenting sponsor

Microsoft is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=5s) [Microsoft presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/9f227e03d5413a3f145480f3998b2dc3d19988d231e026e1f23d34ccc7102bb5.webp)

PRESENTING SPONSOR

Microsoft

### Innovation and platinum sponsors

AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=10s) [AWS is the innovation sponsor; MongoDB, Google Cloud and Neo4j are platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/630a2c443ecc7597c52e9d1aeb861e20a19a5346dd1d271a75cb61d0c3f5b66c.webp)

INNOVATION SPONSOR

aws

PLATINUM SPONSORS

MongoDB®
Google Cloud
neo4j

### Iteration is everything

Hypermode built its platform to make AI features easier to iterate on. Over the next 50 minutes, attendees will build a couple of AI features and improve them incrementally.

[0:26](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=26s) [Hypermode slide states that iteration is everything.](https://assets.ai.engineer/sites/aiecode2025/sha256/a4b5532ac5e2ad81a17d3ffb344477cc39cb3f24e25b8868f032d86f7e2d0e4b.webp)

At Hypermode, we believe iteration is everything.

AIE
aws

### Let’s ship some AI features!

The workshop will build and iteratively improve AI features. To condense the session, participants will push directly to main.

[0:32](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=32s) [Slide reads “Let’s ship some AI features!” with sparkle symbols.](https://assets.ai.engineer/sites/aiecode2025/sha256/082ad29de6d876f7ad6a361731efb1a8157a4f12aba60591988ee383478df144.webp)

Let’s ship some AI features! ✨

AIE
Microsoft
smol ai

[0:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=43s) [Title slide reading “Let’s ship some AI features!”](https://assets.ai.engineer/sites/aiecode2025/sha256/3751a86df0f3b4c590c3d403bf2abafc9ec47217fc70ad93dd0bcd03d7206ddf.webp)

Let’s ship some AI features! ✨

AIE
aws

### Agenda

The talk starts with an AI-scaled game, breaks down its use of large and small models, then applies those building blocks to GitHub issue triage and other apps.

[0:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=58s) [Agenda: play an AI-scaled game, examine its construction, apply its building blocks to GitHub issue triage, and generalize them to other apps.](https://assets.ai.engineer/sites/aiecode2025/sha256/b2df99efc741043e69ec60392f56448cd145bfe001aa565572f6c2c3dc4db39e.webp)

Agenda

1. Play a familiar game, using AI to scale the format
2. Understand how the game is constructed, with large and small models
3. Apply the same building blocks to an app triaging GitHub issues
4. Generalize the concepts for adding AI to your apps

AIE
Microsoft
smol ai

### Hypercategories rules

Players choose an entry for each category that starts with the given letter. A qualifying answer earns one point, split among players who give the same answer—for example, “table” for furniture starting with T.

[1:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=93s) [Rules ask players to provide unique entries matching a starting letter and category; players split points for identical answers.](https://assets.ai.engineer/sites/aiecode2025/sha256/01b2d83bdd552703adc37977b7ffef57f7905e1ed1a35ca333f6d01e09ceced0.webp)

Hypercategories
Rules

Prompt: Given a starting letter, provide the most unique entry that matches each category.

Scoring: You’ll receive a point for each qualifying entry, but you’ll split the point with others who submitted the same answer.

AIE

[2:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=134s) [Rules explain choosing unique answers for a starting letter and splitting points for matching answers.](https://assets.ai.engineer/sites/aiecode2025/sha256/36d9b3df429070bda9c85565bc9d5110a3dd8d0655dc1d4d10a1f86044f41670.webp)

Hypercategories
Rules

Prompt: Given a starting letter, provide the most unique entry that matches each category.

Scoring: You’ll receive a point for each qualifying entry, but you’ll split the point with others who submitted the same answer.

AIE
aws

### Hypercategories game round

Players scan a QR code to enter T answers across five categories against a bot. The hosts let the round continue past the countdown while people keep typing.

[2:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=173s) [A game round shows a QR code, the letter T, five categories and a countdown.](https://assets.ai.engineer/sites/aiecode2025/sha256/0c5072251327aded69b5f26168a501bb1a7d73365eab4f838488915eb272fea6.webp)

T

A thing you wear
Bird
Seen in a zoo
A type of berry
Types of fish

Countdown
01:43

AIE
Microsoft
smol ai

Interface text:
Workshop - AI Engineer Worl...
Hypercategories
AI Engineer World's Fair Worl...
Hypermode
Just Ship AI (by Hypermode)
Hypercategories
localhost:8501
RUNNING...

[3:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=199s) [A QR code beside the letter T, five categories, and a countdown.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d3de9ca8034488496a645d6a43486c5758fbcf4eba527d5e5eb56e567d749a6.webp)

T

A thing you wear
Bird
Seen in a zoo
A type of berry
Types of fish

Countdown
01:14

Hypercategories
AIE
aws

Interface text:
Workshop - AI Engineer Worl...
Hypercategories
AI Engineer World's Fair Worl...
Hypermode
Just Ship AI (by Hypermode)
Hypercategories
localhost:8501
RUNNING...
Stop
Deploy

### Hypercategories results

Kirkbyers and francisco-perez-sorrosal tie at 3.33, ahead of the fourth-place bot. An expanded result marks “tevas” invalid; the presenter flags the judgment as an evaluation error.

[4:56](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=296s) [Leaderboard for the T round, with two players tied on points and the bot in fourth place.](https://assets.ai.engineer/sites/aiecode2025/sha256/448e0fadfbd5f4aed5b9d0619d65a84e5cbb62ba28a3e855baec714a16ef15a3.webp)

Letter: T

1  Kirkbyers  3.33
2  francisco-perez-sorrosal  3.33
3  tetianagrinberg  3.17
4  Hypermode Bot  2.67
Leafsicle  2.5

AIE
Microsoft
smol ai

Interface text:
localhost:8501
Deploy
Hypercategories
Hypermode
Just Ship AI (by Hypermode)

[5:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=338s) [Expanded game results show category responses, validity judgments and scores.](https://assets.ai.engineer/sites/aiecode2025/sha256/b091141a44a70cf563dfefeb711cbb14497debcaf81f9c386b84d0ea05be790c.webp)

Response received at 2024-06-26T20:07:33.389Z

A thing you wear: tevas
invalid response - Score: 0

Bird: tallow
valid response - no similar response - Score: 1

Seen in a zoo: toddler
valid response - no similar response - Score: 1

A type of berry: tayberry
valid response - 2 similar responses - Score: 0.33333334

Types of fish: tiger shark
valid response - no similar response - Score: 1

2  francisco-perez-sorrosal

AIE
AI Engineer World's Fair

Interface text:
Workshop - AI Engineer World's Fair - Google Slides
docs.google.com
Memory usage: 203 MB
Hypercategories
Hypermode
Just Ship AI (by Hypermode)

### Hypercategories: Logical Flow

Hypercategories filters user and bot answers by starting letter, category and dictionary validity, then clusters similar answers for scoring. For example, table and tables count as the same answer.

[5:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=346s) [User and bot responses pass through starting-letter, category and dictionary validation, then response clustering and a leaderboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/119ffd92f6a88d8cf5b1651ebbbe6dcdcbfeb8bf2dd078a48200b157d9aedf58.webp)

Hypercategories
Logical Flow

User Responses
Bot Responses

Filter
Validate Starting Letter
Validate Category
Validate Dictionary Word

Score
Cluster Responses

Leaderboard

AIE
AI Engineer World's Fair
Microsoft
smol ai

[5:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=353s) [User and bot responses pass through starting-letter, category and dictionary validation, then response clustering for the leaderboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/f89eb6e99781249585913121a49e97fed26b3c1afb78ca47fcf1bc66ee46800b.webp)

Hypercategories
Logical Flow

User Responses
Bot Responses

Filter
Validate Starting Letter
Validate Category
Validate Dictionary Word

Score
Cluster Responses

Leaderboard

AIE
AI Engineer World's Fair
Microsoft
smol ai

### Hypercategories: Components

Hypercategories combines functions and models with a user-response collection for similarity search. Connections link the game to data sources and APIs.

[7:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=431s) [Lists functions, a user-response collection, models and connections used by Hypercategories.](https://assets.ai.engineer/sites/aiecode2025/sha256/76da3627f2c898e476aaf32f678cec1eff1bd84fbc8b12db1ba199400dc20da9.webp)

Hypercategories
Components

Functions
startGame
filterEntries
scoreEntries
generateBotResponses
getLeaderboard

Collections
userResponses

Models
MoritzLaurer/roberta-base-zeroshot-v2.0-c
sentence-transformers/all-MiniLM-L6-v2
gpt-4o

Connections
hypermode
mypostgresdb
dictionaryapi.dev
api.openapi.com

AIE
AI Engineer World's Fair
Microsoft
smol ai

### GitHub Issue Triage: Logical Flow

The workshop proposes triaging submitted issues by type and similarity, then summarizing repository trends. The flow ends with a possible repo bot.

[8:03](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=483s) [A submitted issue enters triage for issue-type labeling and similar-issue identification, followed by trend summarization and a possible repository bot.](https://assets.ai.engineer/sites/aiecode2025/sha256/7625be97580078cb500dd48515e287365c4471dd9212d310a0bb6118e9f6959a.webp)

GitHub Issue Triage
Logical Flow

Issue Submitted

Triage
Label Issue Type
Identify Similar Issues

Analyze
Summarize Trends

Repo Bot?

Interface text:
AIE
AI Engineer World's Fair
aws

### AI Engineer World's Fair Workshop

The workshop documentation guides participants through building an AI demo for classification, natural-language search, and summarization. The visible prerequisites include a GitHub account that can create a repository.

[8:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=504s) [Workshop documentation introduces an AI demo using classification, natural-language search, and summarization, with prerequisites below.](https://assets.ai.engineer/sites/aiecode2025/sha256/03d3515c53ed9ff6167171c3894ddeb11807d4901b1a3afeb7ba4dd99dc59859.webp)

Get Started
AI Engineer World's Fair Workshop
git push, get AI API

In this workshop you’ll build a demo that augments an app with AI for classification, natural language search, and summarization. Then you’ll learn how to iteratively improve before and after shipping to prod. We’ll use Hypermode to move fast and reduce infra overhead. You’ll walk away with a greater intuition for when & how to integrate AI without refactoring.

If you need help at any point, please don’t hesitate to ask.

Prerequisites
To get the most out of this workshop, you’ll need:
– A GitHub account where you can create a new repo

Interface text:
docs.hypermode.com/worlds-fair-workshop#deploy-the-changes-for-similarity-search
Search or ask...
Support
Docs
Home
Blog
Templates
Get Started
Introduction
Quickstart
AI Engineer World's Fair Workshop
Configure Project
Project Manifest
[illegible]fine Models
[illegible]fine Hosts
[illegible]fine Collections
Trend summariza[illegible]
Issue type classif[illegible]
Modify the fun[illegible]
Deploy the cha[illegible] classification
Test the classi[illegible]
Issue similarity se[illegible]
Define a collec[illegible]
Create the em[illegible]
Create the sea[illegible]
Deploy the cha[illegible] search
Insert issues d[illegible] collection
Test the simil[illegible]
Production-ready[illegible]
What's next
AIE
AI Engineer World's Fair
Microsoft
smol ai

[8:31](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=511s) [Hypermode workshop documentation introduces a demo using classification, search, and summarization.](https://assets.ai.engineer/sites/aiecode2025/sha256/b454e60660938e749679f3a1ce74118f2c5ce28bc94ad77c3a7e4adb4b46477c.webp)

Get Started
AI Engineer World's Fair Workshop
git push, get AI API

In this workshop you’ll build a demo that augments an app with AI for classification, natural language search, and summarization. Then you’ll learn how to iteratively improve before and after shipping to prod. We’ll use Hypermode to move fast and reduce infra overhead. You’ll walk away with a greater intuition for when & how to integrate AI without refactoring.

If you need help at any point, please don’t hesitate to ask.

Prerequisites
To get the most out of this workshop, you’ll need:
– A GitHub account where you can create a new repo

Interface text:
docs.hypermode.com/worlds-fair-workshop#deploy-the-changes-for-similarity-search
Search or ask...
Support
Docs
Home
Blog
Templates
Get Started
Introduction
Quickstart
AI Engineer World's Fair Workshop
Configure Project
Project Manifest
[illegible]fine Models
[illegible]fine Hosts
[illegible]fine Collections
Trend summariza[illegible]
Issue type classif[illegible]
Modify the fun[illegible]
Deploy the cha[illegible] classification
Test the classi[illegible]
Issue similarity se[illegible]
Define a collec[illegible]
Create the em[illegible]
Create the sea[illegible]
Deploy the cha[illegible] search
Insert issues d[illegible] collection
Test the simil[illegible]
Production-ready[illegible]
What's next
AIE
AI Engineer World's Fair
aws

### GraphiQL trend summary query

The presenter shows a trend summary query for Hugging Face’s transformers repository in Hypermode’s GraphiQL editor, then asks the audience for another repository to try.

[22:55](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1375s) [Hypermode’s GraphiQL editor shows a trend summary query for a repository.](https://assets.ai.engineer/sites/aiecode2025/sha256/09fb38719bbff8c1ea824246ea41d195dc22af3b58ad8481a9ceda408b98438e.webp)

query GetTrendSummary {
  trendSummary(owner: "huggingface", repo: "transformers")
}

Interface text:
Hypermode
mjp-2 / Github Issue Triage (2)
Home
Query
Inferences
Function Runs
Deployments
Settings
GetTrendSummary
ClassifyIssueText
FindSimilarIssues
GraphiQL
Variables
Headers
Support
Docs
hypermode.com/go/mjp-2/ghtriage2/query
AIE
AI Engineer World's Fair

### GitHub issue trend summary and inference history

The demo summarizes the top 100 issues from the .NET runtime repository, then opens inference history to inspect model runs, durations, inputs, and outputs.

[23:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1405s) [A GraphiQL response summarizes repository issues by test failures, platform concerns, performance and API proposals.](https://assets.ai.engineer/sites/aiecode2025/sha256/a16960e2ab7e224884ac3ac17b0ef85a06d1fa2737f72888ed09767a8088b4c0.webp)

query GetTrendSummary {
  trendSummary(owner: "dotnet[illegible]
}

{
  "data": {
    "trendSummary": "Based on the issues created in the repository, several trends and focal points can be identified:\n\n1. **Test Failures and Fixes**:\n  - There's a notable number of issues related to test failures, such as the regression tests, AccessViolationException, and specific test failures under certain conditions like `VolatileTest` under `GCStress`.\n\n2. **Platform-Specific Issues**:\n  - Many issues target platform-specific concerns, including Android (`RC2` algorithm not supported, `SslStreamCertificateContext`), Apple mobile platforms, and BIGENDIAN definitions for different architectures like s390x.\n  - There are issues related to ARM64 and ARM32, indicating ongoing work to support or optimize performance on these platforms.\n\n3. **Performance Optimization**:\n  - Several issues focus on optimizing performance, including constructor performance improvements, JIT optimizations, and reducing locking durations in various components.\n\n4. **API Proposals and Enhancements**:\n  - There are multiple API proposals, such as adding new [illegible]"

Interface text:
hypermode.com/go/mjp-2/ghtriage2/query
Hypermode
mjp-2 / Github Issue Triage (2)
Home
Query
Inferences
Function Runs
Deployments
Settings
GetTrendSummary
ClassifyIssueText
FindSimilarIssues
GraphiQL
Variables
Headers
Support
Docs
AIE
AI Engineer World's Fair
Microsoft
smol ai

[25:18](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1518s) [Hypermode inference history lists model runs, durations, and truncated inputs and outputs.](https://assets.ai.engineer/sites/aiecode2025/sha256/cb9823ba32c0bb0c98521d35f19b313109f5df53f4631afd60711b65789c4bf8.webp)

Inference History
Search by input/output...

Model | Source Model | Provider | Host
Timestamp | Duration | Model | Input | Output
2024-06-26T20:26:08.840Z | 7,345 ms | text-generator | {"model": "gpt-4o", "messages": [... | {"id": "chatcmpl-[illegible]
2024-06-26T18:56:14.584Z | 2,829 ms | issue-classifier | {"instances": ["Unable to export ... | {"predictions": [{"lab[illegible]
2024-06-26T18:52:37.061Z | 1,356 ms | issue-classifier | {"instances": ["AutoTokenizer: Ph... | {"predictions": [{"lab[illegible]
2024-06-26T18:52:00.967Z | 1,152 ms | issue-classifier | {"instances": ["AutoTokenizer: Ph... | {"predictions": [{"lab[illegible]
2024-06-26T18:48:50.457Z | 8,161 ms | text-generator | {"model": "gpt-4o", "messages": [... | {"id": "chatcmpl-[illegible]
2024-06-26T18:48:31.181Z | 8,188 ms | text-generator | {"model": "gpt-4o", "messages": [... | {"id": "chatcmpl-[illegible]
2024-06-26T18:47:35.043Z | 9,183 ms | text-generator | {"model": "gpt-4o", "messages": [... | {"id": "chatcmpl-[illegible]

Interface text:
hypermode.com/go/mjp-2/ghtriage2/inferences
Hypermode
mjp-2 / Github Issue Triage (2)
Home
Query
Inferences
Function Runs
Deployments
Settings
Features
AIE
AI Engineer World's Fair
Microsoft

### Inference input

The inference detail shows the GPT-4o request: a system prompt asks for repository trends, and the user message supplies issue text. The presenter describes using these records to debug model calls.

[25:26](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1526s) [An inference detail panel shows a model request and repository issue text, partly cut off at the right edge.](https://assets.ai.engineer/sites/aiecode2025/sha256/51818981e1e7047e5a28783261860cd0911e88765227c646214e11822e65a703.webp)

Input
{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "system",
      "content": "Provide a summary of the trends in the rep[illegible]
based on the issues created."
    },
    {
      "role": "user",
      "content": "2024-06-26T20:03:43Z From JulieLeeMSFT : T[illegible]
Regressions/coreclr/GitHub_89834/test89834/test89834.cmd\n20[illegible]
26T18:17:08Z From jkoritzinsky : Set value for BIGENDIAN\n20[illegible]
26T18:10:59Z From buyaa-n : Add ValueType to the core types[illegible]
emit\n2024-06-26T17:56:01Z From EgorBo : Improve getStaticFi[illegible]
for classes without cctors\n2024-06-26T17:44:14Z From omajid[illegible]
dispose EventLog if there was an Interop.Errors.ERROR_INVALI[illegible]
\n2024-06-26T17:39:10Z From kg : [wasm] Repair very old merg[illegible]
update comments\n2024-06-26T16:50:13Z From jakobbotsch : JIT[illegible]
call arg building\n2024-06-26T16:35:34Z From MrON : [API Pro[illegible]
\"Multipart/form-data\" serializer\n2024-06-26T16:27:00Z Fro[illegible]
tannergooding : Update Mono to handle various other vector b[illegible]
APIs\n2024-06-26T16:20:40Z From eiriktsarpalis : Fix JsonNod[illegible]
performance regression\n2024-06-26T16:16:09Z From avivanoff[illegible]
System.IO.FileSystem.AccessControl depends on deprecated ver[illegible]

Interface text:
OpenAI
hypermode.com/go/mjp-2/ghtriage2/inferences
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Inference output and token usage

The inference history retains the model’s repository-issue summary and token usage, even though the demo code did not use the returned usage data. This run used 3,027 tokens: 2,542 prompt and 485 completion tokens.

[25:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1540s) [An inference output panel displays token counts and a generated summary of repository issue trends.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1355f64462c517ee63ed332b0884e9cf9b780ba456c9406ae918e48527132b8.webp)

Output
{
  "id": "[illegible]",
  "model": "gpt-4o-2024-05-13",
  "usage": {
    "total_tokens": 3027,
    "prompt_tokens": 2542,
    "completion_tokens": 485
  },
  "object": "chat.completion",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Based on the issues created in the repository, several trends and focal points can be identified:\n\n1. **Test Failures and Fixes**:\n  - There's a notable number of issues related to test failures, such as the regression tests, AccessViolationException, and specific test failures under certain conditions like `VolatileTest` under `GCStress`.\n\n2. **Platform-Specific Issues**:\n  - Many issues target platform-specific concerns, including Android (`RC2` algorithm not supported, `SslStreamCertificateContext`), Apple mobile platforms, and BIGENDIAN definitions for different architectures like s390x.\n  - There are issues related to ARM64 and ARM32, indicating ongoing work to support or optimize performance on these platforms.\n\n3. **Performance [illegible]"

Interface text:
hypermode.com/go/mjp-2/ghtriage2/inferences
AIE
AI Engineer World's Fair
aws

### Function runs and logs

Hypermode groups logs by function execution. The expanded trendSummary run shows it fetching issues from dotnet/runtime and completing successfully; earlier runs remain visible below for debugging.

[26:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1564s) [Hypermode lists function runs with an expanded successful run showing its log messages.](https://assets.ai.engineer/sites/aiecode2025/sha256/af6bd31bb3a7ab73e376ea9b84ae9ae44d9416e1db08934397e466c0e1deef30.webp)

Function Runs
Search by log message...
Function  Status  Sort

95t10sg  trendSummary  8.8s at 2m ago
2024-06-26T20:26:08.100Z  Calling function.
2024-06-26T20:26:08.100Z  Getting Github Issues for dotnet/runtime
2024-06-26T20:26:16.187Z  Function completed successfully.

95t10s0  classifyIssue  2.83s at 1h ago
95t10rg  classifyIssue  1.35s at 1h ago
95t10r0  classifyIssue  1.15s at 1h ago
95t10qg  trendSummary  8.60s at 1h ago
95t10q0  trendSummary  8.71s at 1h ago
95t10pg  trendSummary  9.92s at 1h ago
95t10p0  trendSummary  0.12s at 1h ago

Interface text:
hypermode.com/go/mjp-2/ghtriage2/function-runs
Hypermode  mjp-2  Github Issue Triage (2)  Support  Docs
Home  Query  Inferences  Function Runs  Deployments  Settings
AIE
AI Engineer World's Fair
aws

[26:22](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1582s) [Hypermode function runs with an expanded execution log.](https://assets.ai.engineer/sites/aiecode2025/sha256/374e195fb85b3959d48bbf834a1d770638768b714f86a0e152776f0f333c623c.webp)

Function Runs
Search by log message...
Function  St[illegible]

95t10sg  trendSummary  8.[illegible]
2024-06-26T20:26:08.100Z  Calling function.
2024-06-26T20:26:08.100Z  Getting Github Issues for dotnet/runtime
2024-06-26T20:26:16.187Z  Function completed successfully.

95t10s0  classifyIssue  2.8[illegible]
95t10rg  classifyIssue  1.3[illegible]
95t10r0  classifyIssue  1.1[illegible]
95t10qg  trendSummary  8.6[illegible]
95t10q0  trendSummary  8.7[illegible]
95t10pg  trendSummary  9.9[illegible]
95t10p0  trendSummary  0.1[illegible]

Interface text:
hypermode.com/go/mjp-2/ghtriage2/function-runs
Hypermode  mjp-2  Github Issue Triage (2)  Suppo[illegible]
Home  Query  Inferences  Function Runs  Deployments  Settings
EXPLORE
[illegible]odels
Features
AIE
AI Engineer World's Fair

### Deployments

The deployment list shows the repository’s initial commit and its Git hash. The presenter says the hash links out to help track who changed what over time.

[26:31](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1591s) [Hypermode deployments page showing an initial commit.](https://assets.ai.engineer/sites/aiecode2025/sha256/96e28709f27c9e64f33b330f07f990c087d6fcbf3759688724060b4ac2bec2cd.webp)

Deployments
Search by deployment message...
Author
St[illegible]
d9c2f30  Initial commit  1h ago by mattj[illegible]

Interface text:
hypermode.com/go/mjp-2/ghtriage2/deployments
Hypermode
mjp-2 / Github Issue Triage (2)
Suppo[illegible]
Home
Query
Inferences
Function Runs
Deployments
Settings
EXPLORE
[illegible]odels
Features
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Issue classification function

The classifyIssue function joins an issue’s title and description, sends them to a classification model, and returns the first predicted label. The speakers plan to use and then modify the function in the workshop.

[27:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1639s) [Code combining an issue title and description and invoking a classification model.](https://assets.ai.engineer/sites/aiecode2025/sha256/d3dbf63d0e0c004a5d98ef3d2fa02b649951098e65d77387059bb60d348a596d.webp)

export function classifyIssue(
  id: string,
  title: string,
  description: string,
): string {
  console.log(`Classifying issue ${id}`);
  const summary = `${title}\n${description}`;

  const model = models.getModel<ClassificationModel>("issue-classifier");
  const input = model.createInput([summary]);
  const output = model.invoke(input).predictions[0];

  console.log(`Issue ${id} classified as ${output.label}`);
  return output.label;

Interface text:
ghtriage2
classify.ts  trends.ts  github.ts
functions > assembly > classify.ts > ...
Ln 1, Col 1  Spaces: 2  UTF-8  LF  TypeScript  Spell  Prettier
AIE
AI Engineer World's Fair
Microsoft
smol ai

[27:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1644s) [Code combines an issue title and description, invokes a classification model, and returns its predicted label.](https://assets.ai.engineer/sites/aiecode2025/sha256/75f700e07538395d1317dd87c9c69b44633c08fe46aa32f66c12983e8930b0b1.webp)

export function classifyIssue(
  id: string,
  title: string,
  description: string,
): string {
  console.log(`Classifying issue ${id}`);
  const summary = `${title}\n${description}`;

  const model = models.getModel<ClassificationModel>("issue-classifier");
  const input = model.createInput([summary]);
  const output = model.invoke(input).predictions[0];

  console.log(`Issue ${id} classified as ${output.label}`);
  return output.label;
}

Interface text:
ghtriage2
classify.ts  trends.ts  github.ts
functions > assembly > classify.ts > ...
main  Ln 1, Col 1  Spaces: 2  UTF-8  LF  TypeScript  Spell
AIE
AI Engineer World's Fair
Microsoft
smol ai

### GitHub issue classification

The demo combines an issue’s title and description and passes them as an array to a GitHub-issue classification model from Hugging Face.

[28:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1709s) [Code comments identify a model tailored for GitHub issues above the classification function.](https://assets.ai.engineer/sites/aiecode2025/sha256/a3d56aa5d615c79c638307348d80ebfccf9cd35d223b3baa012a74e3ec1146c9.webp)

import { models } from "@hypermode/functions-as";
import { ClassificationModel } from "@hypermode/models-as/models/experimental[illegible]

// This function classifies an issue based on its title.
// The model used is tailored for GitHub issues.
[illegible] See https://huggingface.co/AntoineMC/distilbart-mnli-github-issues

export function classifyIssue(
  id: string,
  title: string,
  description: string,
): string {
  console.log(`Classifying issue ${id}`);
  const summary = `${title}\n${description}`;

  const model = models.getModel<ClassificationModel>("issue-classifier");
  const input = model.createInput([summary]);

Interface text:
AIE
AI Engineer World’s Fair
ghtriage2
classify.ts | trends.ts | github.ts
functions > assembly > classify.ts > ...
main | Ln 7, Col 1 | Spaces: 2 | UTF-8 | LF | TypeScript | Spell

[29:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1744s) [Code editor showing classifier imports, comments and the beginning of an issue classification function.](https://assets.ai.engineer/sites/aiecode2025/sha256/e3801687721e2eac10883738b59a2f4f8840570163d0fdd77f2b51dee1eddd5d.webp)

[illegible]mport { models } from "@hypermode/functions-as";
[illegible]mport { ClassificationModel } from "@hypermode/models-as/models/experimental/[illegible]

[illegible]/ This function classifies an issue based on its title.
[illegible]/ The model used is tailored for GitHub issues.
[illegible] See https://huggingface.co/AntoineMC/distilbart-mnli-github-issues

[illegible]xport function classifyIssue(
  id: string,
  title: string,
  description: string,
[illegible]: string {
  console.log(`Classifying issue ${id}`);
  const summary = `${title}\n${description}`;

  const model = models.getModel<ClassificationModel>("issue-classifier");
  const input = model.createInput([summary]);

Interface text:
AIE
AI Engineer World’s Fair
ghtriage2
classify.ts | trends.ts | github.ts
functions > assembly > classify.ts > ...
main | Ln 7, Col 1 | Spaces: 2 | UTF-8 | LF | TypeScript | Spell

### Classification model input

The demo passes one issue summary as an array to the classification model. The input also accepts multiple strings, allowing several issues to be classified in one model call.

[29:18](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1758s) [Code editor with a tooltip explaining that the model input accepts one or more text strings.](https://assets.ai.engineer/sites/aiecode2025/sha256/e013826af8b8e1024138b2f7668513a1fbb708340122eb506366d5d98475cfd5.webp)

[illegible]xport function classifyIssue(
  id: string,
  title: string,
  description: strin[illegible]
[illegible]: string {
  console.log(`Class[illegible]
  const summary = `$[illegible]

  const model = mode[illegible]
  const input = model.createInput([summary]);
  const output = model.invoke(input).predictions[0];

  console.log(`Issue ${id} classified as ${output.label}`);
  return output.label;

(method) ClassificationModel.createInput(instances: string[]): ClassificationInput

Creates an input object for the classification model.

@param instances — A list of one or more text strings to classify.
@returns — An input object that can be passed to the invoke method.

Interface text:
ghtriage2
classify.ts
trends.ts
github.ts
functions > assembly > classify.ts > ...
Ln 7, Col 1
Spaces: 2
UTF-8
LF
TypeScript
Spell
Prettier
AIE
AI Engineer World's Fair

## Full transcript

[0:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=0s) [upbeat music] At Hypermode, we believe iteration is everything, right?

[0:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=17s) That's why we built a platform that makes it really easy to iterate over AI features. And over the course of today, over the next 50 minutes really, you're gonna be able to build a couple of AI features and incrementally iterate on them, right?

[0:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=28s) And we think that incremental iteration is everything, and so that's why we're gonna walk through it.

[0:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=33s) So let's get started. As we dig in, there's a few things to be aware of. We are just launching, so I'm sure there'll be a couple things that break, so bear with us on that, but we'll work through it.

[0:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=43s) Um, we are gonna skip some steps to just condense this. So you're gonna push right to main. That's okay. That's always fun. Um, but let's, uh, let's really just kind of start to dig in.

[0:55](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=55s) And overall in the agenda, we're gonna start with really kind of showing you a, a few different ways where this plays out. So we're gonna start by playing a familiar game, where we're using AI to scale the format.

[1:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=67s) Then we're gonna understand how that game's constructed and kind of break it down to the building blocks, and then start to apply those into triaging GitHub Issues. We picked that because there's open data that we can easily use on that.

[1:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=77s) You can think about applying that to a lot of different contexts, whether that's customer records or product records or other things in your application. But we'll start with GitHub Issues and talk about how we can generalize those concepts to add AI to your application.

[1:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=89s) So we've created a game that we call Hyper Categories. It's like the familiar game Scattergories, but it works for a bigger format of people, right? That, the traditional game doesn't really work, uh, for more than six or eight people.

[1:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=101s) So we're gonna invite you all to play with us, so you'll need your phones in a second for a QR code to kind of join into this. But the prompt really is, is pretty simple.

[1:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=108s) Given a starting letter, provide the most unique entry that matches each category. You'll get a point if you actually match the category and you start with the right letter, but you'll share that point with anyone else that says something similar.

[2:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=120s) So if the category was furniture and the letter was T, and you said table, anyone else that says table, you're gonna share that point around that, that way. So you need to be unique, right?

[2:09](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=129s) And we'll talk about how we're using AI to kind of power this. But it also helps you to, um, start to think of act- think about the building blocks that you're gonna use, right?

[2:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=137s) So let's actually jump in. We'll play and then we'll kind of break it down afterwards with how it's actually running.

[2:26](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=146s) We do. We have a, uh, a Hypermode jacket for whoever wins, so...

[2:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=153s) So Matt's gonna get that built and running.

[2:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=155s) There we go. All right.

[2:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=160s) Oh.

[2:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=161s) And let me... Can everybody see that? All right. We are playing with things that start with the letter T, so please, uh, scan that QR code if you can.

[2:52](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=172s) Hopefully everybody can. If not, there is a link to it in the, uh, in the doc that accompanies this workshop.

[3:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=182s) Which they can get to how?

[3:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=184s) Yep. [laughs]

[3:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=187s) Uh, hype.foo/workshop, right?

[3:10](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=190s) Yep.

[3:10](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=190s) Okay, great. We'll let it go a little longer than the, the countdown timer here.

[3:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=197s) Yeah. It won't, it won't cut off, so if you haven't joined in yet, feel free.

[3:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=214s) There is a bot playing against you as well, so...

[3:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=218s) I'm curious to see, uh, the creativity that people come up with here. [laughs]

[3:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=224s) The bot tends to pick the o- obvious answers, so it doesn't do very well in this one.

[3:56](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=236s) Need some music. Little Jeopardy music. [laughs]

[4:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=254s) There we go.

[4:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=255s) Thank you. [laughs] A little improv there. [upbeat music playing] Yeah. I see people typing still, so we'll give, we'll give it a little bit more time.

[4:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=280s) All right, we can end it whenever you like.

[4:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=288s) I see most phones down, so another five seconds?

[4:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=293s) Five-

[4:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=294s) Why don't we see the results?

[4:55](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=295s) ... four, three, two, one. [snaps fingers] All right.

[5:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=300s) Where is Kirk Byers? Congratulations, come see us after. We'll g- grab you a jacket.

[5:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=307s) Awesome to see.

[5:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=307s) Oh, yeah.

[5:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=307s) So you see the bot there in, in fourth place, so great job for three of you for beating the bot.

[5:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=312s) And we have a tie for first.

[5:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=314s) Oh yeah, sorry. I admit- look at it. Uh, Francisco,

[5:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=319s) awesome. So come see us after. We, we have two jackets. We can make that work.

[5:22](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=322s) Shall, shall we look at the results?

[5:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=323s) Yeah, let's look at it.

[5:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=324s) All right. Things you wear.

[5:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=327s) Tevas. Oh, that got an invalid. So we'll, we'll dig into that. AI's not always perfect in the evaluation. Okay. Still won.

[5:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=335s) We, we need to train the model better.

[5:36](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=336s) Yeah. Cool. So why don't we jump over to show you how this is actually working behind the scenes. This is a d- a template that you can deploy. You can play it back at, at your company or wherever you're at.

[5:45](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=345s) But really, we start to think about these type of AI applications.

[5:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=350s) Can we get the screens lined up?

[5:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=353s) Sure can. The one on the left is a little off there.

[5:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=354s) Oh, there we go. Um, as these building blocks, right? That you're starting to put, to assemble these into your application. Right. So when you submit that response or when the bot submits the response, we score that as well.

[6:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=364s) We validate the starting letter, we validate the category, right? And so we are using a model to make sure that you are hitting that category as we saw in the results there.

[6:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=371s) It's not always perfectly right. We can continue to train that. But one of the things we learned as we were building this was if the letter was P and the thing was occupation, you could type in P doctor and the model would think that that was valid, right?

[6:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=384s) So that's why we added a dictionary validation as well. And we really see this as illustrating th-the way we see the world of AI applications are developed. It's this mix of models and traditional programming paradigms that come together that actually make it useful, right?

[6:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=398s) So we have that filtering stage, and then we go into the scoring stage, and we start to cluster those responses. We look at it and say, "If you said table and someone else said tables, we consider those the same answer," right?

[6:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=408s) So we're using, um, those processes to make sure that those things are matched, and it's not just an exact text search match. These are ways you could start to scale this game to a size of this group, right?

[6:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=418s) And then that responds to the leaderboard. And we show all this just so you start to get a feel for how these things are assembled. It's a, a set of building blocks.

[7:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=426s) Behind this is a set of functions, models, and data sources, right? So you start to think about this at a, at a deeper level. It's basic programming concepts, right?

[7:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=437s) We have a set of functions. We have a collection of user responses that we're doing similarity search across, a set of models that help power both those functions directly as well as the embeddings for the models or for the collections.

[7:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=448s) And we're gonna walk through all this in the n-next example, and you're actually gonna get hands-on it and build these pieces into some connections, right? Whether that's within Hypermode itself, to out to your database, to a traditional API, to a model host.

[7:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=460s) We make it really easy to stitch all that together.

[7:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=463s) And so that's what we wanna show you now is really to apply these concepts into triaging Gi- Gi- GitHub issue. So if anyone has ever worked on an open source project, you s-- you know that you get GitHub issues from a wide variety of sources, and quality is not always great, right?

[7:57](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=477s) So we thought, what if we could actually apply AI to make it easier to triage those issues, to understand what type of issue it was, were there similar issues that may be already reported or trends that you're starting to see, and actually be able to summarize trends coming out of the repo, right?

[8:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=491s) So that's the part that we would love for you to build with us.

[8:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=495s) So-

[8:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=496s) You guys ready? We're gonna, we're gonna build this. Actually build it. Uh, if you've got laptops out, that'd be good. Uh, I'm gonna get out of here, and we're gonna, we're gonna kinda work together.

[8:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=505s) The, uh, all this is documented, by the way, um, kinda chronologically the way we're gonna follow in the workshop. Um, and to get to there, there's a, uh, a short link, which is, uh, what is it?

[8:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=515s) hype.foo/workshop. That'll just take you into our di- docs link, or you can go to docs.hypermode.com and, and go find the AI World's Fair tab here on the left. Um, and feel free to browse around the rest of the docs and learn about Hypermode as you go.

[8:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=530s) Um, this is the platform we're using to build this, but also the concepts we're gonna go through here really could, could work any way that you're building an application that's going to leverage AI and functions and data and all that stuff here.

[9:01](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=541s) Um, let's see. We already, we already kinda went through a lot of this basic stuff with hypergories. Um, I will just say for prereqs, um, if you hadn't seen this earlier, um, hopefully you've got some kinda text editor.

[9:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=551s) I like to use VS Code. Um, you'll need Node.js twenty or higher. Um, and that's, that's pretty much it. Um, obviously Git and, and some way to, uh, to, to clone a repo and so forth.

[9:21](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=561s) I like to use GitHub Desktop, so you might see that flash on and off, but you can use the command line or whatever you're comfortable with. Um, so let's, um, let's start with GitHub issue, uh, triage.

[9:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=573s) We're gonna go to this website we set up called [REDACTED:url]. Um, and this is, um, this is something we just launched, so, um, we'd love to hear any feedback you may have from it.

[9:45](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=585s) There are a lot of other templates on here, but we're gonna work with this GitHub issue triage template for the sake of this workshop. Um, and if you're following along, so just click on the GitHub issue triage, and we're gonna click...

[9:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=598s) It's gonna tell you a little bit about the t- the template. You can click to go view the template, but we're just gonna de-- we're gonna go right ahead and deploy it.

[10:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=604s) Um, now for most of you, this will be the first time that you've, um, been into Hypermode. So, um, you will get a screen that looks like this, but when you go to connect it to your GitHub account, it's gonna ask you to sign in.

[10:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=616s) Um, and that would be a normal, uh, GitHub login. So if you, if you don't have GitHub, then you would need a GitHub account in order to continue. Question in the front.

[10:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=623s) Um, if I sign in, if I sign in, I need to give it access to all my current and future repositories. If I only select one existing one, it doesn't work.

[10:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=633s) You should only need to give it access to the repository that we're, uh, working with today. If you're seeing something different, we'd love to see what that looks like. [chuckles]

[10:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=643s) Okay.

[10:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=643s) Um, yeah. They, uh... And, and if, if you have any concerns about that and, and don't wanna continue, you could just watch along or we could, um, we could, we could check afterwards.

[10:52](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=652s) I know that... I can't remember the exact detail, but I know that there's something on GitHub where some of the wording that GitHub gives you on that first link is a little confusing.

[11:01](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=661s) But, um, yeah-

[11:01](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=661s) It, it's only requesting repos per-permissions. That screen is a little confusing of the first time if you don't have any existing repos.

[11:08](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=668s) Yep. Um, so you're gonna basically, uh, this is me here, Matt Johnson-Pint. And, uh, if you have other orgs, of course, you can, you could pick them here.

[11:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=677s) Um, and you can name your repo anything you want. Uh, you can make it private or public. Um, but we're gonna create that. And, um, I'm gonna go to the one that I pre-created.

[11:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=688s) It should land you, when all is said and done, let me find it, on something that looks like this.

[11:37](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=697s) Um, so we'll go through this a little bit more later, but this is basically, um, setting up cloning a template off of GitHub. Um, and if you look on GitHub, you'll see that there is a template, let me zoom in, um, that was cloned from the ship issue triage, um, template repo.

[11:57](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=717s) And it's pretty bare bones. Um, it's got some, some boilerplate set up, but most everything we're working with here today is gonna be in this functions directory.

[12:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=727s) Uh, let me go back to the doc and just see where we're at for

[12:13](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=733s) moving things along. This will give them a little time to, to do that.

[12:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=743s) Update Hyper category, set up local environment. Um, okay. So once we, once we have that, we're gonna wanna clone it, right? So you can git clone it.

[12:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=753s) Um, I have already Git cloned that repo. Um, so if I open it in Visual Studio Code, I will be looking at something that looks like, like this. I'll just pause for just a few minutes to make sure that everybody can clone the starter template.

[12:51](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=771s) You're gonna see me work with it for a little bit too, so if you're a little behind, that's fine. Um, you can always, um, catch up later or just, uh, cont- continue to watch.

[12:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=779s) Um, I will point out that, um, you may see some things in red even though everything is fine, and I'm gonna just show you how to get rid of that.

[13:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=787s) When you first clone the repo, um, you wanna s-- um, cd into the functions directory, and you're gonna do an npm install. That's gonna go download all the dependencies off of, um, the Node Package Manager.

[13:20](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=800s) And notice they're still in red. There is a little quirk in VS Code that we haven't quite figured out how to avoid. At this stage, you can, um, you need to open a TypeScript file.

[13:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=809s) But you can, you can do a few different things. You can just restart the TypeScript language server, and it-- the red will go away. Um, this is a, a VS Code issue that, that I've got an open issue on with that team.

[13:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=820s) But, um, it does install correctly.

[13:42](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=822s) Yeah, two questions here. So when you're on Just Ship AI, should you deploy on this, um, with GitHub? Can you reassure me on that?

[13:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=830s) Sure. The question was if you are on Just Ship AI, should you deploy or just go to GitHub? Um, if you view it on GitHub, you're just gonna see the template.

[13:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=838s) And GitHub will also let you just use this template directly. It's up in the upper right-hand corner. But, um, you can go through that step, but it's a little easier if you just go through the deploy, and we'll automate that for you.

[14:08](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=848s) 'Cause we're not-- we're also installing the Hypermode application. If you go through the, uh, through the green button on GitHub, then you'll have to import your project into Hypermode after the fact.

[14:20](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=860s) If you click on the deploy button-

[14:21](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=861s) Yeah, if you click on the deploy, that's creating your org and everything on, on Hypermode.

[14:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=863s) Yeah. [background chatter]

[14:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=868s) Jay, can you take a look at what they're s- [chuckles]

[14:32](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=872s) We're g- s-- If, if people are having difficulties, we're, we're gonna send you somebody over, and hopefully it's not everybody in the room. [chuckles]

[14:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=881s) But yes, please, we can, we can make this interactive within, uh, within certain time constraints. Um, there's nobody in the room after us, but we know you have other sessions to go to also, so we wanna keep this-

[14:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=890s) Yep

[14:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=890s) ... on track. Shall I continue?

[14:56](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=896s) Yep.

[14:57](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=897s) Okay. So we've installed the project. I've installed the dependencies. Let's, let's build it. So we're gonna use, uh, npm here. If you're used to Yarn or, or Bun or any pnpm, those should all work.

[15:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=911s) Um, but I'm gonna do npm run build.

[15:13](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=913s) And you're gonna get some output that has our, uh, nice little pretty, um, ASCII art that I'm wearing right here. And it's gonna give you some metadata about your library, and it's gonna describe that there, hey, there are two functions in this, um, in this starter template.

[15:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=929s) There's one called classifyIssue, and there's another one called trendSummary. Um, so together, we're gonna take a look at those two functions, and so we can understand how it works and, and what, what we're actually doing here.

[15:39](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=939s) And then I'm gonna actually run some of these for you so you can see, like, them in action.

[15:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=944s) Um, so let's just go look at... I'm actually gonna take them backwards order here. They're listed alphabetically. But we're gonna look at the trendSummary first. Um,

[15:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=953s) this particular one, if we look at this, um... I'll make one other quick call-out. So, um, you may, if you're a web developer at all, you may see this and say, "Oh, we're in a TS file, and it looks like we're writing TypeScript."

[16:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=966s) We're actually writing something called AssemblyScript, which is a TypeScript-like language that uses a lot of the, um, the same features of TypeScript and a lot of the same ecosystem as TypeScript.

[16:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=975s) Um, the reason we're using AssemblyScript is because all of your Hypermode functions are getting compiled to WebAssembly, and that's how we actually execute all of this code that you're writing in a nice, secure, fast, uh, performant manner, um, as it's running and part of the Hypermode platform.

[16:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=988s) Um, won't dwell on that too much, but that's, uh, that's the, the intent here. Um, Hypermode will get support for other languages in the future. This is what we're using today. [chuckles]

[16:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=998s) Um, so what are we, uh, using from here? We're us- we're gonna use, uh, for this first one, we're gonna use, um, OpenAI, and you'll see that we import an OpenAI chat model and a couple system message and user message objects so we know how to use it.

[16:51](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1011s) I've got another, uh, little helper function that I wrote here. Let me just close that. Um,

[16:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1018s) that is going to go get some issues from GitHub. And if I drill into that, j- this is not AI at all. This is just a, an HTTP REST call.

[17:05](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1025s) GitHub has a nice API that you can use to go fetch data, and I'm gonna fetch data, um, pass in some parameters into a template. I can even do a little logging so I can see what's going on.

[17:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1036s) Um, requires some headers. Um, there's a little comment here that, like, we have, we have a little secrets management system, so you don't have to put secrets in your code, and we can still pass your, your GitHub API tokens through securely and so forth.

[17:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1048s) Um, ultimately, you get your data. We come back and say, "Hey, there's some issue data. We're gonna throw it in an issues object so we can start working with it in the rest of your code."

[17:36](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1056s) And that's what you're getting back here in this issues. Let me hover over. It's an issues object. It's an array of issues, right? 'Cause it said, "Hey, go get some giss-- GitHub issues."

[17:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1066s) So once we have the issues, what are we gonna do next? Um, we're gonna, we're gonna need to build a prompt to send off for analysis. 'Cause what we want here is we're gonna take a whole bunch of information from the issues, and we're gonna say, "Hey, uh, OpenAI," in this case, uh, we're gonna use GPT-4.0, um,

[18:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1082s) "would you summarize these for us?" Uh, what's the overall trend is the, is what we're asking for. Um, so it's not just summarize the issues, but like some-- "Give me a trend."

[18:10](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1090s) So that's part of my, my instruction off to there. "Provide a, provide a summary of the trends of their repository, repository based on the issues created." And, um, and we're gonna just send OpenAI, like a constructed string that includes like the timestamp, um, the user handle so it can kind of get some analysis, um, and like the

[18:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1109s) issue title and, uh, and we're, we're passing all that through into, um, OpenAI. The other thing I'll, I'll call out for you here is like now we're into some, um, Hypermode specific code that we call our model interface.

[18:43](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1123s) And, uh, this model that I'm looking at, it is an OpenAI chat model, so it ha- it knows everything about the OpenAI API. You don't have to go over and read the OpenAI docs in order to construct this, this, uh, API call.

[18:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1134s) You just say, "Hey, I'm going to use the OpenAI chat model," and when I create input, it's telling me right here on the IntelliSense and the type ahead, I can just say create some messages.

[19:03](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1143s) It's gonna take some messages. I've got a bunch of different messages of different types. Um, even goes as far as like optional parameters. Here I show temperature. Um, so a lot of people when they're brand new to AI they're like they never heard this term before.

[19:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1154s) What is, what is temperature? I don't know what that is. And then you see top-p and like people are like I don't, I don't get that. Um, it's really intuitive for a developer to just say, you know, um, I can just say input. and I get like here are all the different options.

[19:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1167s) There's like logprobs and n and parallel tool calls and all the different options that GitHub has, uh, or sorry the OpenAI has. And, um, you know, I can read them individually.

[19:37](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1177s) Uh, if I use them incorrectly it won't compile. Um, all that, that kind of stuff that you would expect from, um, a strongly typed client library and we've, we've baked that into Hypermode.

[19:47](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1187s) Not just for OpenAI, but for other models as well. We've got some out of the box and we're gonna be expanding on them and we've designed the system so that if we don't support a certain model's interface you can write it yourself.

[19:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1198s) There's nothing that, uh, that prevents you from doing that. You can just inherit from a base class and, and write the implementation.

[20:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1206s) I'll pause there for a second because I feel like that was a lot of words. [laughs]

[20:10](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1210s) This is a pretty basic RAG use case, right? We're fetching some data, we're passing it to the model to ask for summarization. You could do this a lot of ways, right?

[20:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1217s) At Hypermode we make it really easy to stitch all those pieces together, right? And you can start to iterate through that, right? To Matt's point, you can try new models, right?

[20:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1224s) And you don't have to go learn a new model and understand a different model uses temperature in a different way or has different thresholds on it. Right here when you invoke a new model, do input.temperature, you're gonna see that right there in context.

[20:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1234s) And so we find that it makes it a lot more productive for users as they're starting to stitch these things together, not having to make any of these choices and really kind of hard choices up front knowing that you can always swap them out really easily.

[20:45](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1245s) One of the things we found when we were designing this is that um, um, a lot of the, the use cases seem to believe that all models were interchangeable and we found just through testing that like it's just not the case.

[20:56](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1256s) Um, not only are our prompts different and outputs are different, but also like um, the different hyperparameters are different, the different, um, ways you can control the APIs are different.

[21:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1264s) Like uh, everybody's got their own little custom snowflake tweaks and we needed a way to consolidate that, that so that a user can very easily get to all the different options that are available.

[21:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1274s) So this is the API we came up with and I'd love feedback about that for any of our like API design engineers that are in the room. [laughs] Come talk to me after.

[21:22](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1282s) Um, all right, so git-- uh, OpenAI returns me some complex things. It's there, there is the ability in OpenAI to have multiple choices. We're just gonna take the first one and we're gonna take that message and this may seem like a little thing but like, um, once I get the content of that string I, I could do

[21:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1298s) other things with it. I could-- in this case all I'm gonna do is just trim it because like sometimes it comes back with extra characters. But say I wanted to throw it in a database, or I wanted to log it, or I wanted to go call another model with that input, um, as soon as I say that to

[21:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1310s) people they're like, "Oh, like LangChain." Like well kind of it's just, it's just programming. It's just like you're taking in one input and you're, you manipulating it to do the next thing.

[21:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1318s) Um, so let's, let's just run this. So what does that mean when we run it? Um, in this case it's already in Hypermode because I cloned from the template.

[22:05](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1325s) But say I'd just written this, all I'd have to do and this is the, where the title comes from is just git commit, git push. Uh, and we pick it up, um, automatically and roll that out into your Hypermode console which I'll go back to.

[22:18](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1338s) This is the one we're looking at. Um, and um, you'll see that I've got trendSummary on here. Um, now I've already configured this, um, back end to have an API key off to OpenAI which you would need.

[22:30](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1350s) Um, but if you were doing it yourself you would go over to host and you would need a GitHub token as well because we're gonna go pull issues off GitHub, right?

[22:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1358s) Um, so let's run this. We got a little query tab here that uses GraphiQL. It's a, it's a built-in thing. We may, we may replace that with something a little more, uh, interactive later but it, it works for, for now.

[22:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1368s) And um, I use Hugging Face transformers but let's-- uh, somebody have, somebody throw out a favorite repository. I need the, uh, the org name and the... Anybody have another one?

[22:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1379s) Anyone? Anyone? I'll pick something at random. Okay, I used to be, for a long time I was a C# developer. Um, don't hold that against me. So I'm gonna go, let's go see what's going on in the .NET runtime and, and I haven't tested this so we'll just see what happens here.

[23:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1395s) It's gonna go fetch the top hundred issues off of .NET runtime repo and within a few seconds here it has summarized it and said, "Hey, there's the trend summary."

[23:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1404s) Um, and you notice, um, we made a GraphQL call, um, but I didn't have to write any GraphQL schema. Um, Hypermode automatically generates the GraphQL schema based on the functions that you export.

[23:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1415s) So all I had to do was make this function trendSummary and tell it what its inputs are and it now has a full lit up GraphQL endpoint. Um, I happen to be calling it from the Hypermode console but you could use another tool like Postman, uh, has a really good GraphQL interface or if you use any

[23:50](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1430s) GraphQL client where you want or you could just use curl, um, on the command line and write into a script or your favorite HTTP client. You could use anything you want.

[23:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1439s) Um-

[23:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1439s) Matt, we've got a question.

[24:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1440s) Yeah. Question. Um, will it create GraphQL types from inferred from the TypeScript types? It does. The quest-- Yeah, uh, I'll repeat the question. It says, um, does, does Hypermode create the GraphQL types from inferred from the TypeScript types?

[24:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1456s) It does. Um, that is part of the Hypermode experience. Uh, it will even create custom scalars for you if you have those. Uh, there are some limitations but we are, we are actively engineering to try to overcome them.

[24:28](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1468s) The biggest limitation you'll see right away is at the moment, um, input types are, are not supported. Uh, but you can have structured output types. So input types at the moment have to be all scalars, um, or arrays.

[24:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1478s) But um- Say you have your custom object in GraphQL, we'll let you supply that. But we, we need to do some engineering work to make that work. [laughs]

[24:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1488s) Great.

[24:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1488s) Yeah. Um, it's a really nice way to, like, um, define your code once. Um, and you have a single source of truth, and it can be in a file you import.

[24:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1498s) If you're in a corporation that has lots of libraries, you can, you can make separate libraries for this, and it's just, it's just the npm package ecosystem. So it just folds in like you would expect.

[25:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1506s) When we support other languages, it'll be whatever the package ecosystem is for those languages. We're not trying to do anything special here.

[25:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1512s) So Matt, here, why don't we show what you get as well when you run that query, right? So if you go to the inferences tab,

[25:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1519s) you'll see actually a history of this model run, right? 'Cause we know that when you start to actually run models, you need more observability into that, right? Your app may be triggering things from the front end, dynamically pr- uh, prompting that model.

[25:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1529s) So we make it really easy to see every time you hit a model, you're gonna get one of these entries to understand how long it took, what was the input, and what was the output, right?

[25:37](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1537s) And so you can start to debug this with, with additional visibility, and we find that makes it really easy, especially if you're starting to chain multiple models together in a single function.

[25:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1544s) Yeah, like if I wanted to know, well, how many tokens did, um, OpenAI consume for that? It did return that to me, but I didn't use it in my code.

[25:51](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1551s) I could have. But I... Even though I didn't use it in my code, I do have it in our inference history, so you can go back and, and say, "Oh, that, that prompt, you know, took three thousand tokens."

[25:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1559s) Yep. And then you also have access to, to raw logs of, of the functions as they run, right? So you can log things out to that. You'll see system logs a- a part of that, and they're all kind of, uh, oriented based on each individual function execution, right?

[26:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1574s) So you can have high volumes of overlapping functions. Makes it really easy to debug here to understand what's going on, how models are being invoked, what the specific inputs and outputs of those are-

[26:22](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1582s) Yeah

[26:22](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1582s) ... so that you can continue to iterate and understand what's going on.

[26:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1585s) This is the one I just ran. Um, these are some ones I was running earlier, but we'll, we'll show you those in a minute. Um, there's a whole bunch of stuff, other stuff on here.

[26:32](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1592s) One of the interesting one is like deployments. Um, I've only done one on this repo. This is the initial commit. But as we push, you'll see that, like you have the Git hash, and you can click to link over there, and it makes it real easy to like, see who changed what over time.

[26:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1604s) And, um, okay. Um, let's go on to... So this one, we're not gonna, um, have you guys implement yourself because I don't want anybody in here to, to have to supply an OpenAI key or GitHub token right now.

[26:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1618s) But like I said, they, they are in the starter template and workshop. You can do that on your own time, however you like. We're gonna go on to the next one, which I think everybody can do here together 'cause, uh, we're going to actually run the model on Hypermode rather than, uh, externally.

[27:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1631s) Yep.

[27:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1632s) Is that the right spot in the sequence? I think so.

[27:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1634s) Yep.

[27:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1634s) Okay.

[27:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1635s) Yeah.

[27:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1636s) Bear with us if, uh... We're just going through presentation, uh, coordination here. Um, okay. So the next one we're gonna look at, like I said, there's two functions that are in, in this, um, starter template.

[27:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1647s) Um, the next one is classifyIssue, and we're gonna, we're gonna use this at first, and then I'm gonna have you guys modify it. We're gonna actually put your code to work here.

[27:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1654s) So if you've never written AssemblyScript or anything before, just pretend it's TypeScript. If you run into a thing where like it says, "Hey, I don't know what type that is," that's, that's where you get into AssemblyScript.

[27:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1661s) It's in there. I can answer those questions, but it's pretty straightforward. Um, uh, so, uh, what does this function do? Well, w- in this case... So this is gonna be a little disconnected from the last one we did, but, uh, because it's not gonna go query GitHub.

[27:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1674s) It's just gonna take as inputs the title and the description and an issue ID. And we're gonna, we're gonna log some information on what we're doing, and we're gonna s- we're gonna just build a really dumb, uh, prompt here of, um, or input anyway, of summarizing the, uh, the title and the description concatenated together.

[28:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1692s) Um, in a real app, you'd wanna play with this a little bit and figure out what the right exact input that matches the model you're using. Uh, oh, let's talk about the model.

[28:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1699s) Um, so this model is, uh, called DistilBERT MNLI GitHub Issues. We found it on Hugging Face. Um, this is a, a, a con- con- community contributed model, I believe.

[28:30](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1710s) Yep.

[28:30](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1710s) Um, but it's pre-trained on GitHub Issues, so it's a purpose-built model. We don't need to spend time model training here. We don't need to start with anything big. This is a s- a really small model.

[28:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1718s) Um, it's, it's good for like just deciding whether a GitHub issue is, uh... I believe it's, it tells you whether it's an issue, a bug, a feature request.

[28:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1726s) Or a question.

[28:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1726s) Um, or a question.

[28:47](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1727s) Yep.

[28:47](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1727s) Yeah. That's what it... so it's gonna do. Um, the interface for this, uh, you'll see we import classification models from our models.js library. Um, this word experimental, don't be scared off by that.

[28:58](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1738s) It's just we're trying to make sure that, um, we are careful about when we, uh, finally call it not experimental. Um, but this will match most of the classification models that are on Hugging Face at the moment.

[29:09](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1749s) Um, and, uh, yeah. So what are we gonna do? We're gonna, we're gonna build a prompt. We're gonna say, "Hey, get that classification model." And now I've got, uh, an input that in this case requires, um, one or more input strings as an array.

[29:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1763s) And the reason it's one or more is 'cause you can classify things in batches. I could say, "Hey, there's are, there are ten GitHub issues I would like you to classify."

[29:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1769s) I only need to make one model call for that. Um, and, and, and that's why I've got prediction zero, the first prediction coming back, 'cause I'm only asking for one.

[29:38](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1778s) But, um, those would match the, the inputs and outputs.

[29:42](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1782s) And again, if there were other options here, you could say input. In this case, it's the only one. Um, but we would wrap that up for you in the interface.

[29:51](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1791s) And then we'll just log output. So this, this is really simple. Um, again, I've already got it running, so let's just run it. And, um, the queries for these, by the way, are, are pasted into the docs.

[30:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1800s) If you're following along in the docs, let me just make sure I show you where we are. We are at issue type classification, and there's some description there. But basically, this is the code we're working on.

[30:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1811s) Here's the example query we're gonna run. I'm gonna paste this query. Um, and this, this query's got a lot of, um, what looks like junk in it, but it's because we just took literally the entire text of the query, um, off of GitHub, um, and made sure it was properly escaped and stuff.

[30:26](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1826s) So if you were using the GitHub API, it would work. Um, if you're literally like with your mouse copying and pasting text, you may find, um, like getting the new lines in there and the quotes escaped might just be a little tricky, uh, on the fly.

[30:39](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1839s) But if you had input from an app, it would be doing that for you. It's just, it's a string in and a string out, right?

[30:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1844s) Um, but let's go run that guy Where am I? Make sure I'm in the right area. I think I've already got it in here. Yeah, I'll just paste it anyway, just make sure.

[30:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1854s) Is that the one? It didn't paste correctly. There might be a docs issue there. This one I know works. Um,

[31:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1864s) maybe something I need to fix in the docs. I don't know if Jay can fix that. The, uh, the one that's in the docs isn't, uh, escaped properly, so when I copy and paste it, it's, it's got new lines in there.

[31:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1875s) Weird. [laughs] Um, but basically everything I'm putting in should be in the description. If, if you do get, um... If you're trying this out and you get some weird error like, like this doesn't work, um, just reduce it down to s- to some string in here just so you can, you can follow along.

[31:31](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1891s) Um, we'll make sure we clean up the example later. Ideally, it would be the entire thing of the issue. Um, indeed this is the, the classification category that came out 'cause it's a real issue.

[31:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1901s) Um-

[31:42](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1902s) So, so what's, what's happening here, just to kind of highlight some of the contrast here, right? So when you deployed this project, this small model, different than kind of OpenAI's models, right?

[31:51](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1911s) Uh, this small model actually got provisioned automatically in Hypermode. So when you're running this query, you're running against a dedicated instance of this model just for your project, and you can start to customize and, and adjust that, right?

[32:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1920s) And so really wanted to show you these two functions to kind of show you the contrast, but also the similarities, right? The model, uh, interfaces are relatively similar and pretty intuitive to make it easy to kind of continue to iterate through that.

[32:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1931s) Mm-hmm.

[32:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1931s) Why don't we jump ahead slightly just in the interest of time-

[32:13](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1933s) Sure. How are we on time?

[32:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1935s) And actually start-

[32:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1935s) Okay. Yeah, I see

[32:15](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1935s) ... start building, um, a vector s- or natural language search.

[32:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1939s) Well, one, one thing I would like to do is just give people a few minutes to do some-

[32:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1944s) We don't have time.

[32:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1944s) We don't have time. [laughs] Okay.

[32:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1945s) Sorry. Um-

[32:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1947s) Uh-

[32:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1947s) Your, your projects will continue to run. If you could reference the docs, you're welcome to continue to iterate with this. We can spend all the time with you after to, if, if you'd like to, but-

[32:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1954s) We won't do it, but the suggestion in the docs, and there's a walkthrough, is like how would I add a threshold to this function and say, "Hey, I, I, I need to know based on its confidence, like how, how accurate is this label?"

[32:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1966s) Um, and that's something you don't need to train a model on. It's just code. You just write it. There's a, there's a, um, instead of just that, there's confidence score.

[32:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1973s) So you can decide what the confidence score you want is and, and do some comparisons and just write that code.

[33:00](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1980s) But we'll let, we'll let people on their own.

[33:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1982s) But, yep. So why don't we jump ahead to building a natural language search to identify similar issues, right? Oftentimes people report repeated issues, and wouldn't it be great if there could be a bot that responds to every issue saying, "That sounds a lot like these three other issues"?

[33:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1996s) That's what we're gonna build in the next twelve minutes.

[33:18](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=1998s) Okay. [laughs] Sorry for the rush, guys. Um, like I said, uh, there's nobody in the room after. We'll be around, so if you wanna walk through it slower, if you have questions-

[33:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2007s) Yep

[33:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2007s) ... we will help you. Uh, uh, okay, so we're gonna go, we're gonna start writing some new stuff. Let's, uh, let's just take this directly from the docs so that we can walk through it together.

[33:37](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2017s) The first thing we're gonna do is we're gonna create what we call a Hypermode collection. Um, and basically, it's like where are you gonna store your data? Um, Hypermode isn't a database, but we give you a very simple way to have an in-memory key value store that we can apply an index to.

[33:52](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2032s) Um, and that way we can, um, basically do your vector search in, in memory, in Hypermode. Um, so first we have to go to our manifest and say, "Hey, there's, um, there is a collection."

[34:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2042s) So far we haven't talked about the manifest, but you'll see in the root there's a file called hypermode.json, and it has models. It has the two models we've been using so far.

[34:09](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2049s) It has hosts, which were the, uh, both for the, um, the, the first example. Um, that's how we get out to other, other places, and I'm going to add that collection.

[34:19](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2059s) So I'm just gonna drop it right in here. Um, so we have our collection file. That's all we have to do. Um, and there's some additional, uh, options and stuff that we're not gonna go through them all right now.

[34:31](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2071s) Um, the next thing we're gonna do is we're gonna add another model. So one of the things with, um, if we're gonna do a vector search, we need to know, well, what model are we creating our embeddings off of, right?

[34:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2081s) Um, and we don't want you to think about that too much, but you do have to, um, supply a model. So we're gonna take another one from Hugging Face, and we're gonna go add it to the model section.

[34:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2093s) Boom. We're gonna use MiniLM, uh, from Sentence Transformers.

[34:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2099s) And, uh, and you'll see that syntax in the, in the documentation, but basically it's just that's the source of the model we're using. It's gonna be hosted on Hypermode, and we got that from Hugging Face.

[35:08](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2108s) That's it. Save that. And, uh, I'm gonna do a, um,

[35:16](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2116s) I'm gonna commit that for a minute. So let's do command line, git add everything, and git commit,

[35:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2127s) um, um, add collection and model. Okay. And then it's... We've got nice Git signing on, so it's asking me to authenticate. But once that's in, I can git push, and just from the push, it's gonna start spinning up that model in Hypermode.

[35:47](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2147s) Now, you didn't have to do that at this step. You could do the code and then do it all at once, but this just gives it time to warm up a little bit since we're, uh, under a time constraint.

[35:55](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2155s) Um, the next thing I'm gonna do is I'm going to, uh, go grab the embedder function. So we need an embedder function. Um, you know, you know how that...

[36:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2166s) We, we showed you the model interface a couple times. Well, this time we're gonna use an embeddings model. And I'm gonna go create a new file.

[36:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2174s) New file, embedder.ts, and I'm gonna paste that in here.

[36:21](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2181s) And, uh, I won't walk the whole thing, but basically, um, embedders need a text in and an array of vectors out, and the vectors are f32 arrays. So it looks like a two-dimensional array, but it's an array of array of f32s.

[36:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2195s) Um, and that's an AssemblyScript thing that we have a concept of a f32 instead of just a number. Um, but that's basically how that works, and we're gonna create it, and we're gonna just return all the predictions.

[36:45](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2205s) Um, one thing I have to do also is I have to, um... The way that this is, these exports work is, uh, I have to go to my index file and actually just make sure I include it

[36:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2214s) Otherwise, it's not gonna leave the module when I build. Um, at this stage, I should be able to npm... Oh, I have to go to the functions directory, and I can say npm run build, and we should see it.

[37:07](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2227s) Yeah. The embedder is, is in the output. It's still not searchable though. Like this, if I were to run it at this stage, you'd see the array of all those floats, and it's kind of not very usable from a, a user's perspective.

[37:21](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2241s) Um, so let's grab the actual function that's gonna do the search, and that's also in the docs. So I'm just gonna copy that in,

[37:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2249s) and I'm gonna do the same sort of thing. I'm gonna come here and say new file, um, search, we'll call it. It can be called anything. I'm gonna paste that in, and be- and before I show it to you, I'm gonna make sure I don't forget to export it.

[37:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2261s) Sometimes I forget to, uh... Not from GitHub. We're gonna from search.

[37:47](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2267s) Okay. Um, and I know we're tight on time, but just real quick, what does this look like?

[37:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2273s) Um, it's gonna do a few things. Um, it's gonna define, uh... It's gonna import our collections object. It's gonna define a class that's gonna be, um, for our similar issues.

[38:05](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2285s) This is, you're asking that can we return structured objects? Yes, I'm doing it right here. I return a similar issues array, and we automatically get GraphQL generated in our, our output schema.

[38:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2294s) Um, I'm going to search the collection using the information we have in the manifest, and this time I'm gonna say, "Just give me the top three," and I do want the text and the results.

[38:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2303s) Um, often you don't. Often you just say, "Give me the ID back," 'cause I'm gonna go query a database using that ID. And so for you to return me the text, if it's big, could be an extra step we don't, you don't need to do.

[38:33](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2313s) Um, that's it. Return them. Uh, return me an object using the, the output of that, that search. Let's, uh, let's do the git push and, um, git add ., git commit -m, um, add search functions,

[38:54](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2334s) and git push. And, um, oh, I didn't do-- I probably should have made sure it builds locally. Um, it's going to build it in, in the... Oh, I'm not in the right directory.

[39:05](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2345s) Uh, functions, npm run build. Because if I had a compile error or something, it would happen here, and we are working on improving our local dev experience as well, 'cause ideally, we'd like you to be able to run it here too, but we don't have that just yet.

[39:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2357s) So for now, you, you just push it, and we run it there. Um, notice it says, "Hey, there's a custom data type SimilarIssue." That's gonna be in our new GraphQL.

[39:26](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2366s) We'll go back to Hypermode, and how are we on time?

[39:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2369s) Good.

[39:29](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2369s) Eight minutes. Okay. Thanks for hanging with me here. Let's look at deployments for a second. Notice they're there already. So those are the two pushes that I did. git push, it just works.

[39:39](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2379s) Uh, I can now go to the homepage, and I should see, hey, there's an issues collection, and I've got four functions, and I've got that new model that I added.

[39:48](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2388s) Right. So every- everything we just did, it's already in Hypermode. Um, one thing I wanna do just, uh, for sake of time is I'm gonna go, um, pre-seed this, um, collection with some existing data, and I've got a link to that in the...

[40:02](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2402s) Not there. In the doc. Down at the bottom, there is a link. Here, example CSV file. So we're gonna take these issues which we scraped earlier off of, I think, Transformers.

[40:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2414s) Yes.

[40:14](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2414s) I think that is where we grabbed it from. And I'm just going to download that file from GitHub issues.csv, and I'm gonna go over to Hypermode and, um, and upload them there.

[40:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2425s) Now, you don't have to do it this way. You could write yourself a function that says, um, "Hey, take this other API input and go upload it," or you could call GitHub API and upload it that way.

[40:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2434s) So there's a lot of different ways you can do it, but we're gonna, we're gonna put it in manually right now.

[40:40](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2440s) There it is.

[40:41](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2441s) And what's gonna happen when Matt does this is because of the way that we've set up the collection and the embedding function, every time you add something new to the, the collection, whether that's via your code or via, via this upload, it's gonna automatically embed it, right?

[40:52](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2452s) It's gonna use that function, automatically embed it, and make it available for your search. It's gonna use that same embedding function in the search so that you know that what, what you're searching and what you're searching against have it embedded, embedded the same way, right?

[41:04](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2464s) So you don't need to bring three different systems together to get this working. All in one box, you get natural language search off of these couple of functions.

[41:12](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2472s) There's a little bit of a delay as it's working here, but if I just be patient for a minute and refresh, eventually we'll see the, uh, inference history from those embedding functions should pop up.

[41:23](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2483s) Yep. Those are processing in the background there.

[41:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2485s) Here's to the dem- for the demo gods. [laughs]

[41:27](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2487s) These are the ones that we ran when we were classifying what we should see here. Let's just pick the model. Why do I not see that model? Shouldn't I see the embedder?

[41:36](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2496s) Yeah. Hmm. Do the functions runs work? Let me, let me just try a search and see what happens. I think-

[41:52](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2512s) It's probably still queuing up.

[41:53](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2513s) All right. I'm gonna search... We'll see if it's still going. I think, I think we're getting no results here, or we can, we can just wait a little more.

[41:59](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2519s) But, um, we're going to see if, hey, is anybody... We're gonna search a new issue. Like imagine the workflow here. Somebody writes an issue, says, "Hey, uh, I wanna add a Spanish, uh, version of your README file."

[42:09](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2529s) And so our app that's using these APIs is gonna be like a bot that says, "Hey, uh, we, we may already have that already. You know, maybe other people have asked."

[42:17](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2537s) Um, and indeed... Okay. So it did finish uploading from the collection. Um, we can go figure out why it's not showing in the logs. It should have showed in our logs.

[42:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2545s) Um, but indeed, we can say, "Hey, um, there was a Turkish README, and there's some other bits about languages and a French version of this, but I don't see anything with the Spanish README, so it's probably okay."

[42:35](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2555s) Um, but there aren't any similar issues. Uh, these are the most similar, um, that are available.

[42:42](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2562s) I am curious why that didn't come through. There they are. Just took a second.

[42:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2566s) Yep.

[42:46](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2566s) Okay. We'll work on that. Um, these are batches, uh, by the way, so they're a little long here, but I think what we did is we split them up to like twenty-five at a time, and so they take like, you know, two seconds for that one and one second for that one.

[42:57](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2577s) Um, but we can see the, the history- And like there's the stuff you really don't wanna look at, all of the, uh, the float arrays, right? But that's your vector embeddings.

[43:06](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2586s) And then the search just uses that vector embeddings. That's it.

[43:11](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2591s) I think that's-- I know we kinda rushed through that. I'm sorry. Um, hopefully some of you got a chance to code some of it, but like I said, um, uh, feel free to stick around or to continue to walk through the, the doc on your own time.

[43:24](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2604s) And I'm really ex-excited to see what else you guys want to build. Uh, we have a lot of other documentation off to the side here that you can see, like other stuff we can do.

[43:31](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2611s) You can make HTTP calls. Um, you can, you can, uh... What else can you do? You can work with the collections more, uh, shortly. Not yet, but shortly we'll have ability to go and ran- and connect to any Postgres database that you want to.

[43:44](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2624s) Uh, that's coming soon. Um, and, uh, and yeah, there's like the sky's the limit, right? Pick your models and write your functions and away you go.

[43:55](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2635s) Anything else we wanna show?

[43:56](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2636s) Yeah, no, that's, that's what we had to show you, right? It was like these are a set of building blocks that you can apply in your applications across contexts, across different points of data.

[44:03](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2643s) Hopefully, you start to understand how these pieces work, right? We see this everywhere. Like when we start to look at around and say, there are so many places where you wanna do that natural language sorting or search or bringing these pieces in, and we just need people like you to help bring that into those applications, right?

[44:18](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2658s) And so that's what we really get excited about. We don't want you to have to start from scratch. So that's, as Matt said, we launched Just Ship AI. Those are templates.

[44:25](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2665s) You can deploy those right away. You all have access to Hypermode now. You got a fourteen-day trial. Feel free to respond to that email, and you can claim the credits that Kevin mentioned this morning.

[44:34](https://www.youtube.com/watch?v=R7xlYs5p0yA&t=2674s) Happy to get your team set up, um, and run through this in a more contextual way for you as useful. But thank you. [outro music]
