Compare AI Answers With Live Search

Use AI Gateway search to compare stale and source-backed answers.

Introduction

30 Second Summary

Numbers that change often can be out of date before you use them. A confident answer gives you no clue whether the model checked what is true today.

In this project, you will build a small Node script that asks the same time-sensitive question twice through Vercel's AI Gateway. The output places the plain answer beside a Tako Search answer with its tool call and source.

What You'll Build

You run one question and watch two answers appear side by side, with the search-backed result showing where its current number came from.

By the end of this project, you'll have:

  • A saved side-by-side comparison that shows the plain answer beside the search-backed answer.
  • A traceable result that reveals the tool call plus the source behind the current number.
  • A usage check that shows the run cost in your AI Gateway account.
  • Secret Mission: An optional challenge to push your skills further.

Are there any prerequisites?

You'll need a free Vercel account with Node available on your laptop. The project guides you through creating the AI Gateway key.

Before We Start

A convincing live-data comparison needs a local script plus access to the service that receives its requests. This step gives you both foundations before any key or code enters the project.

You will make sure your Vercel account is ready. You will also prepare Node.js while learning where the future AI Gateway key belongs.

In this step, get ready to:
  • Confirm access to your Vercel dashboard.
  • Verify Node.js plus npm on your computer.
  • Create a local project folder for the comparison script.
Set up your Vercel account

The Vercel dashboard is where you will create the AI Gateway key in the next step. For now, you only need to confirm that you can reach the dashboard.

  • Open the official Vercel login page in your browser.
  • Click Sign Up if you do not have an account.
  • Select Continue with Email on the login or sign-up screen.
  • Enter your email address.
  • Enter the six-digit password sent to your inbox.

You are in. Your Vercel dashboard is now ready for the AI Gateway key you create next.

Keep Your Gateway Key Private

An AI Gateway key authorizes requests from your script. Its safe home in this project is the local .env file.

Calls to Tako Search are free through 30 September 2026. Model usage through the gateway is billed separately.

Check Node.js and npm

Node.js runs the comparison script on your computer. npm prepares the folder so the script can use packages later.

  • Press Cmd+Space on macOS or the Windows key on Windows.
  • Type Terminal on macOS or Windows Terminal on Windows.
  • Press Enter.
  • Check whether Node.js plus npm are available by running:
node -v
npm -v

What Do These Commands Check?

  • The node -v command prints the installed Node.js version.
  • The npm -v command confirms that the package manager is available.

✔️ I see two version numbers

Your local runtime is ready. The two version lines prove that Node.js plus npm can run from your terminal.

ⓧ One check does not run

Node.js installers include npm. Installing the supported release gives you both tools in one setup flow.

  • Open the official Node.js download page.
  • Select the installer labelled LTS for your operating system.
  • Download the installer.
  • Run the downloaded installer.
  • Accept the default installer options.

What Does the Installer Add?

The installer adds Node.js plus npm to your computer. The default options make both commands available in new terminal sessions.

  • Close your current terminal window.
  • Press Cmd+Space on macOS or the Windows key on Windows.
  • Type Terminal on macOS or Windows Terminal on Windows.
  • Press Enter.
  • Check both installations again by running:
node -v
npm -v

What Should You See?

Each command should print a version number. That output confirms the new terminal session can find both tools.

Still Missing a Version Number?

Restart your computer if the installer completed but the new terminal still cannot find a command. This refreshes the system paths used by terminal applications.

Check that the Node.js installer completed with its default options.

Ask for help with your specific setup: Why can my terminal not find Node.js or npm after installation?

Prepare the local project folder

A dedicated folder keeps the comparison script plus its configuration together. You will create it on your Desktop so it remains easy to find.

  • Move to your Desktop by running this command:
cd ~/Desktop

What Does This Command Do?

The cd command changes the terminal's current folder. The ~ shortcut represents your home folder.

  • Create the project folder plus switch into it by running:
mkdir live-data-comparison
cd live-data-comparison
pwd

What Do These Commands Do?

  • The mkdir command creates the live-data-comparison folder on your Desktop.
  • The cd command moves your terminal into that folder.
  • The pwd command prints the current folder path for verification.

The printed path should end with Desktop/live-data-comparison. Your terminal is now working inside the correct folder.

Folder Already Exists?

If the folder already exists, skip the creation command. Move into the existing live-data-comparison folder before continuing.

Ask for help locating the folder: How do I find my live-data-comparison folder from the terminal?

  • Prepare the folder for a Node script by running:
npm init -y
ls

What Do These Commands Create?

The npm init -y command creates a default package.json file without an interactive setup.

The ls command lists the folder contents. It gives you immediate proof that the project file exists.

You should see package.json in the output. The local folder is now prepared for the comparison script.

Do You Not See package.json?

Check that your terminal path ends with live-data-comparison. Run the setup command again from that folder if npm did not create the file.

Ask for help with the project setup: Why did npm not create package.json in my project folder?

  • Press Cmd+Space on macOS or the Windows key on Windows.
  • Type the name of your installed code editor.
  • Press Enter.
  • Use the editor's folder-opening option.
  • Select the live-data-comparison folder from your Desktop.

Your editor should show package.json in the folder. Your terminal should still point to the same project path.

Before you run the final check, what folder name plus version lines do you expect to see?

  • Verify the complete local setup by running:
pwd
node -v
npm -v
ls

What Does This Final Check Prove?

  • The first line confirms that your terminal is inside the local project folder.
  • The next two lines confirm that Node.js plus npm are available.
  • The final line confirms that package.json exists.

You should see a path ending in live-data-comparison. You should also see two version numbers plus package.json.

Does the Final Check Look Different?

A different path means the terminal is in another folder. Return to the live-data-comparison folder before running the check again.

A missing version line points back to the Node.js installation check. A missing package.json means the npm setup ran in a different folder.

Ask for help comparing the results: Which part of my local Node.js setup is incomplete?

Your Vercel account plus local workspace are ready. Next up, you will create the private AI Gateway key that connects the script to the gateway.

Create Your AI Gateway Key

Your local script needs permission to send requests through Vercel AI Gateway. Without a credential, the gateway cannot associate those requests with your account.

An API key provides that credential. You will create one in Vercel before storing it in a private local file.

In this step, get ready to:
  • Create an AI Gateway API key in the Vercel dashboard.
  • Store the new key in a private .env file.
  • Confirm the dashboard lists the key without exposing its value.
Create the gateway key

An API key authenticates each request your script sends through the gateway. Vercel ties the key to the account that creates it.

Vercel displays a new key's secret value only once. It is worth slowing down here because anyone who sees the value can use the credential.

  • Open the Vercel dashboard in your browser.
  • Sign in to the Vercel account you prepared earlier.
  • Open the AI Gateway API Keys page in the dashboard.
  • Click Create key.
  • Name the key live-data-comparison.
  • Click Create API Key.
  • Copy the new key value immediately.
  • Keep the creation view open while you prepare the local file.

The generated value is visible in the creation view. Vercel cannot retrieve the same value later.

Can't create the key?

  • Confirm you are signed in to the Vercel account you intend to use.
  • Return to the AI Gateway API Keys page before trying Create key again.

Why can't I create an AI Gateway API key? You can also ask the Vercel community for account-specific help.

Store the key in .env

The .env file separates your credential from the JavaScript you write later. Your script can read AI_GATEWAY_API_KEY without placing the secret directly in the source code.

  • Switch back to the code editor from earlier.
  • Create a file named .env inside the local project folder using your editor's new-file control.
  • Add the environment variable to .env by using this template:
AI_GATEWAY_API_KEY=your_ai_gateway_api_key

What does this setting do?

  • AI_GATEWAY_API_KEY is the variable name that the gateway tooling reads.
  • your_ai_gateway_api_key marks where your private credential belongs.
  • Keep .env out of source control.
  • Keep the file's contents out of screenshots.
  • Keep the file's contents out of messages.
  • Replace your_ai_gateway_api_key with the key value you copied from Vercel.
  • Save .env.
  • Confirm .env appears in your editor's file list.

Your editor now lists .env in the local project folder. This confirms the file exists without revealing the key.

Don't see the .env file?

  • Confirm you created .env inside the local project folder from earlier.
  • Check that the filename begins with a dot.
  • Confirm your editor did not add a text-file extension.

Why is my .env file missing from the editor?

✔️ Awesome, I've got everything!

Your .env file has the expected variable name. The secret stays only in your local copy.

ⓧ I'd like to double check the full code

  • Compare the variable name and equals sign with the reference below.
  • Leave your real key value in the saved file while you compare.
AI_GATEWAY_API_KEY=your_ai_gateway_api_key

How to compare this file

The placeholder shows where the private value belongs. Your saved file contains the copied key in the same position.

Verify the private setup

The dashboard proves the key exists. The editor proves the private file exists without exposing its contents.

Before you check, what evidence should remain after the one-time key value is hidden?

  • Return to the AI Gateway API Keys page in the Vercel dashboard.
  • Close the key creation view if it is still open.
  • Confirm a row named live-data-comparison appears in the key list.
  • Switch back to the code editor from earlier.
  • Confirm .env remains visible in the local project folder.

That is the sensitive setup complete. Vercel lists the credential without revealing its value.

Your private credential is ready for local requests. Next up, you will use it to send a plain request through the gateway.

Ask Without Search

Your Vercel AI Gateway key is safely stored in .env. Your local script can now authenticate without exposing that key in the code.

A model can still answer a data question without checking a live source. This step creates that plain answer as the baseline for your comparison.

In this step, get ready to:
  • Install the libraries that connect your script to AI Gateway.
  • Create a Node.js script that sends one plain request.
  • Run the script to inspect the answer for vague or dated information.
Install the request libraries

The AI SDK provides the function that sends your prompt through AI Gateway. The dotenv package loads your existing key from .env.

  • Return to the terminal in your local project folder from earlier.
  • Install the required libraries by running this command:
npm install ai dotenv

What Did This Install?

  • The ai package provides generateText() for sending the model request.
  • The dotenv package loads values from .env into the script's environment.
  • Check that the installation finishes without reporting a package failure.

Installation Failing?

  • Confirm the terminal is inside the local project folder from earlier.
  • Confirm your internet connection is active before retrying the installation.

Help me diagnose this installation problem.

Create the plain request

A fair comparison needs one fixed prompt. This script stores the question once before sending it with no external tools attached.

  • Return to the editor you used for .env.
  • Create live-data-comparison.mjs beside .env using your editor's new-file control.
  • Copy the following code into live-data-comparison.mjs:
// Load the key from .env without placing it in this file.
import 'dotenv/config';
import { generateText } from 'ai';

// Keep this question unchanged for the later comparison.
const prompt =
  'How has US electricity generation from solar changed over the past five years? Cite current data.';

// Send a plain request through AI Gateway with no tools attached.
const result = await generateText({
  model: 'openai/gpt-5.6-terra',
  prompt,
});

// Print the baseline answer with a clear label.
console.log('Answer without search:');
console.log(result.text);

What Does This Code Do?

  • The dotenv/config import loads AI_GATEWAY_API_KEY from .env. The AI SDK reads that environment variable automatically.
  • The prompt variable preserves the exact question for the later comparison.
  • The generateText() call sends the question through openai/gpt-5.6-terra with no tools attached.
  • The final two lines label the baseline before printing the model's answer.
  • Save live-data-comparison.mjs.

✔️ Awesome, I've got everything!

Your plain request is ready. Double-check that live-data-comparison.mjs is saved before you run it.

ⓧ I'd like to double check the full code

// Load the key from .env without placing it in this file.
import 'dotenv/config';
import { generateText } from 'ai';

// Keep this question unchanged for the later comparison.
const prompt =
  'How has US electricity generation from solar changed over the past five years? Cite current data.';

// Send a plain request through AI Gateway with no tools attached.
const result = await generateText({
  model: 'openai/gpt-5.6-terra',
  prompt,
});

// Print the baseline answer with a clear label.
console.log('Answer without search:');
console.log(result.text);
Run the baseline request

This run can consume AI Gateway credits. You only need one request to capture the baseline.

Before you run this, ask yourself whether the model can support its answer with a traceable current source.

  • Send the plain request by running this command:
node live-data-comparison.mjs

What Should You See?

You should see Answer without search: followed by the model's response.

The request used no external tool. Any figure or citation in this response came from the model's existing knowledge.

  • Read the answer from top to bottom.
  • Identify any figure that lacks a clear publication date.
  • Identify any source that you cannot trace from the terminal output.

No Answer in the Terminal?

  • Confirm live-data-comparison.mjs is saved beside .env.
  • Confirm .env still contains the AI_GATEWAY_API_KEY entry from the previous step.
  • Confirm the terminal is running the command from the local project folder.

Help me debug my plain AI Gateway request.

You now have a working baseline that shows what the model says on its own. Next, you will attach Tako Search to the same question and compare the result.

Add Tako Search

Your plain request proved that a model can answer a current-data question without checking live information through Vercel AI Gateway. Its answer may sound confident while still being vague or dated.

You will now attach Tako Search to a second request. The model stays fixed. The prompt stays fixed. This isolates the effect of live search.

In this step, get ready to:
  • Make the AI Gateway tool helper available to your script.
  • Attach Tako Search to a second request using the existing question.
  • Run the script to compare both model answers.
Expose the gateway helper

The AI SDK provides built-in tools through the gateway helper. Your script needs this helper before it can make Tako Search available to the model.

  • Switch back to live-data-comparison.mjs in the editor from the previous step.
  • Find the existing import from ai.
  • Replace that import with this line:
import { gateway, generateText } from 'ai';

Why Add Gateway?

The generateText import still sends model requests. The new gateway import exposes AI Gateway tools such as gateway.tools.takoSearch().

  • Save live-data-comparison.mjs.
  • Confirm that the existing untooled request still runs by using this command:
node live-data-comparison.mjs

What Should I See?

You should see the same untooled answer print in the terminal. This confirms that the expanded import works without changing the original request.

Seeing an Import Error?

  • Check that the import includes gateway inside the same braces as generateText.
  • Check that the package name remains ai.

Ask for help with the import error.

Compare the two answers

A tool gives the model another way to gather information during a request. The second call reuses the existing question while making live search available.

  • Find the line console.log(withoutSearch.text); in live-data-comparison.mjs.
  • Add the following search-enabled request below that line:
// Give the second request access to live search.
const withSearch = await generateText({
  model: 'openai/gpt-5.6-terra',
  prompt: question,
  tools: {
    tako_search: gateway.tools.takoSearch(),
  },
});

// Print a clear label before the search-enabled answer.
console.log('\nWith Tako Search:\n');
console.log(withSearch.text);

What Does This Code Do?

  • The second generateText call uses the same model as the plain request.
  • The question variable keeps the prompt identical across both requests.
  • The tools object makes Tako Search available through gateway.tools.takoSearch().
  • The final two lines print the search-enabled answer under its own label.
  • Save live-data-comparison.mjs.

Before you run the comparison, which answer do you expect to use more current data?

  • Compare both answers by running this command:
node live-data-comparison.mjs

What Should I See?

You should see one answer under Without Tako Search:. You should then see another answer under With Tako Search:.

The answers should differ in their wording or figures. The search-enabled response should draw on fresher information.

Seeing One Answer or Matching Answers?

  • Check that the second request appears after the first output in live-data-comparison.mjs.
  • Check that tako_search sits inside the second request's tools object.
  • Keep the frequently changing question unchanged before running the comparison again.

Ask for help checking why Tako Search did not change the answer.

✔️ Awesome, I've got everything!

Your script now sends the same question with two different levels of access. Both labeled answers appear in one terminal run.

ⓧ I'd like to double check the full code

// Load the local gateway credential without exposing it in source code.
import 'dotenv/config';
import { gateway, generateText } from 'ai';

// Reuse one question so tool access is the only changed input.
const question =
  'How has US electricity generation from solar changed over the past five years? Cite current data.';

// Ask the model without access to live search.
const withoutSearch = await generateText({
  model: 'openai/gpt-5.6-terra',
  prompt: question,
});

console.log('\nWithout Tako Search:\n');
console.log(withoutSearch.text);

// Give the second request access to live search.
const withSearch = await generateText({
  model: 'openai/gpt-5.6-terra',
  prompt: question,
  tools: {
    tako_search: gateway.tools.takoSearch(),
  },
});

// Print a clear label before the search-enabled answer.
console.log('\nWith Tako Search:\n');
console.log(withSearch.text);

That comparison is working. Next, you will inspect the tool call plus the returned search fields to trace the fresher answer back to its source.

Print the Search Evidence

That is a strong first result. Your Node script now shows that an AI Gateway answer changes when Tako Search can fetch current data.

A different answer only shows that something changed. This step exposes the tool call, returned fields, and source so you can trace the number to evidence.

In this step, get ready to:
  • Print the model's tool call with its input.
  • Print the returned search fields with the source behind the number.
  • Save both answers with their evidence in comparison-output.txt.
Print the tool call

The complete search response includes a toolCalls collection. Each entry records which tool the model requested and what input it supplied.

  • Return to live-data-comparison.mjs in the code editor from earlier.
  • Update the search-enabled request so its complete returned object remains available after the call.
  • Keep using the object's text value for the search-enabled answer.
  • Save live-data-comparison.mjs.
  • Run the same script command you used in the previous step.

You should still see the plain answer followed by the search-enabled answer. This confirms that keeping the complete response did not change the comparison.

  • Extend the existing output section to print the search response's toolCalls collection.
  • Include each call's toolName value in the printed evidence.
  • Include each call's input value in the printed evidence.
  • Save live-data-comparison.mjs.

Before you rerun, what evidence do you expect after the two answers? The next run tests your prediction.

  • Run the same script command again.

You should see the two answers followed by a tool name and the search input. The tool call proves that the second request reached beyond the model's stored knowledge.

Tool call missing?

Check that you print toolCalls from the complete search-enabled response after the request finishes. Confirm that the second request still contains the Tako Search configuration from the previous step.

If the collection is empty, keep the same frequently changing-number question that already produced a search-enabled answer. Help me inspect why my search response has no tool calls.

Expose the search result and source

The tool call proves that the model requested fresh data. A tool result exposes the returned payload that informed the answer.

  • Update the output section to print the search response's toolResults collection as readable JSON.
  • Include each result's toolName value in the printed evidence.
  • Include each result's output value in the printed evidence.
  • Save live-data-comparison.mjs.
  • Run the same script command again.

You should see the search payload beneath the tool call. Its structure shows the fields Tako Search returned for your question.

  • Inspect the printed result to locate the record that supports the current number.
  • Identify the source attribution attached to that record.
  • Extend the output section to print the supporting record's relevant fields.
  • Add a separate source line using the source attribution you found in the returned payload.
  • Include title and url from any sources entry whose sourceType is url.
  • Save live-data-comparison.mjs.

Before you rerun, do you expect the source to support the precise number in the search-enabled answer? The next output lets you compare them.

  • Run the same script command again.

You should now see the plain answer, the search-enabled answer, the tool call, the returned search fields, and the supporting source. The number has a visible evidence trail.

What does each layer prove?

  • The plain answer shows what the model produces without live search.
  • The search-enabled answer shows the effect of current information.
  • The tool call records the search request made by the model.
  • The returned fields show the data supplied to the model.
  • The source identifies where the supporting number came from.

Source missing from the output?

Inspect the complete output value inside toolResults before selecting individual fields. The source may be nested inside the returned search record.

If the search returned no relevant record, rerun the same question once. Help me find the source attribution in my Tako Search result.

Save the comparison

Terminal output disappears when the session closes. A saved comparison gives you a durable record of both answers and the evidence behind the current one.

  • Select the complete terminal output from the plain answer through the final source.
  • Copy the selected terminal output.
  • Use your code editor's file browser to create comparison-output.txt inside the local project folder from earlier.

You should see comparison-output.txt beside live-data-comparison.mjs in the file browser.

  • Paste the copied terminal output into comparison-output.txt.
  • Save comparison-output.txt.

Before you inspect the file, do you expect its source to match the latest terminal run? The saved record gives you the answer.

  • Scroll through comparison-output.txt from top to bottom.
  • Confirm that the file contains the plain answer.
  • Confirm that the file contains the search-enabled answer.
  • Confirm that the file contains the tool-call details.
  • Confirm that the file contains the returned search fields.
  • Confirm that the file ends with the supporting source.

That completes the evidence trail. Your saved comparison now shows what changed, what the model requested, what search returned, and where the number came from.

Saved comparison incomplete?

Rerun the updated script if the terminal only shows part of the evidence. Copy from the first answer through the final source before replacing the contents of comparison-output.txt.

Make sure the saved file does not contain your API key. Help me check why my saved comparison is missing sections.

Your comparison can now be audited instead of taken on trust. Next, you will return to the AI Gateway usage page and inspect what the run cost.

Check Gateway Usage

Your saved comparison proves that live search can give the model current evidence. It also preserves the source behind the changing number.

The final question is cost. In this step, you will trace the run through Vercel AI Gateway to confirm that Tako Search contributes a zero charge during the free window.

In this step, get ready to:
  • Review the usage recorded for your comparison run.
  • Inspect the search-enabled request's cost breakdown.
  • Confirm that the Tako Search charge is zero during the free window.
Review AI Gateway usage

The Usage view groups request activity over time. It confirms that your comparison passed through the gateway before you inspect its individual charges.

  • Switch back to the Vercel dashboard from earlier.
  • Select AI Gateway in the dashboard sidebar.
  • Select Usage to load your team's aggregate metrics.
  • Set the date range to today.
  • Use the request count to confirm that your comparison requests are included.
  • Review the Spend chart for the same time range.

You should see recent request activity from your script in the selected time range.

Good. Your comparison now has a dashboard record that connects the script run to its spend.

What Does the Spend Chart Show?

The Spend chart shows total AI Gateway spend over time. The individual request details reveal which parts contributed to that total.

Can't See the Recent Requests?

  • Confirm that the selected date range includes the time when you ran the comparison.
  • Wait about 90 seconds for the newest requests to finish appearing in the logs.
  • Refresh the usage view.

Help me find my recent AI Gateway requests.

Inspect the search charge

An aggregate chart shows the overall spend. A request log separates usage from cost line by line.

  • Select Logs in the AI Gateway sidebar.
  • Set the date range to include your latest comparison run.
  • Find the two most recent successful requests from that run.

Before you inspect the search-enabled request, do you expect its search entry to increase the cost during the free window?

  • Inspect the two comparison requests until the request details show Tako Search.
  • Review Usage and Cost in the search-enabled request details.

You should see the Tako Search entry contribute zero to the request cost during the free window. That window closes on 30 September 2026.

You've closed the loop. The dashboard confirms that the search portion of your comparison cost zero.

Why Can the Total Exceed Zero?

The free window applies to Tako Search calls. Model usage through AI Gateway is billed separately, so the complete request can still show a cost above zero.

Don't See the Tako Search Charge?

  • Check the request timestamp against the time of your latest script run.
  • Inspect both comparison requests because the plain request has no search entry.
  • Wait about 90 seconds if the newest request details are still incomplete.

Help me locate the Tako Search cost entry.

Secret mission

Audit the Search Result's Evidence

Turn your saved comparison into a source audit. Trace the search-enabled number back to its evidence. Grade how much trust that evidence deserves.

Clean Up Your Resources

Clean Up Your Resources

Choose whether to keep the project available, pause it securely, or remove it. Local files cost nothing.

When Does Free Search End?

Model usage through Vercel AI Gateway is billed separately from Tako Search.

Tako Search calls are billed at zero during the free window. The free window closes on 30 September 2026.

Resources you used:

  • AI Gateway API key listed in the Vercel dashboard.
  • Local project folder containing .env, live-data-comparison.mjs, and comparison-output.txt.

Keep everything running

No action is needed. Choose this if you plan to run more live-data comparisons.

The local folder stays on your computer with its current credential. Any future script run can add model usage charges.

  • Keep .env out of source control.

Pause - I'll come back to this later

The Node script exits after each comparison, so there is no background process to stop. Deleting the gateway key sounds final, but your script and saved comparison stay untouched.

  • Return to the AI Gateway key listing in the Vercel dashboard from earlier.
  • Open the action menu beside the listed AI Gateway API key.
  • Choose the option that permanently deletes the current key.
  • Confirm the deletion when prompted.

You should no longer see the AI Gateway API key in the key listing. The value stored in .env can no longer authenticate.

That gives you a secure pause. Your script and saved comparison remain ready for later.

Delete - I don't want to use this again

Remove both teardownable resources to start fresh. Permanent cleanup removes the active credential plus every local project file.

  • Return to the AI Gateway key listing in the Vercel dashboard from earlier.
  • Open the action menu beside the listed AI Gateway API key.
  • Choose the option that permanently deletes the current key.
  • Confirm the deletion when prompted.

You should no longer see the AI Gateway API key in the key listing.

  • Locate the local project folder from earlier in your operating system's file manager.
  • Permanently delete the entire local project folder through the file manager's deletion controls.
  • Confirm the permanent removal if your operating system asks for confirmation.

You should no longer see the local project folder in its previous location. The .env, live-data-comparison.mjs, and comparison-output.txt files are now removed.

That's the cleanup done. The live credential and local files can no longer be reused accidentally.

Nice Work!

Strong finish! You built a live-data comparison with Vercel AI Gateway and Tako Search. You proved that a current source matters more than a confident tone.

You've learned how to:

  • Build a Node.js script that sends the same frequently changing-number question without tools. The script sends it again with search attached.
  • Compare an untooled answer with a search-enabled answer. This exposes where stale knowledge can produce vague or dated results.
  • Trace the live answer through the tool call. You also inspected the returned search fields. You saved the source and comparison in comparison-output.txt.
  • Secret Mission: Complete an optional project extension that pushes your live-data verification skills further.

Ready to quiz yourself?