Getting Started with Searches.do: Your First Intelligent Data Query

In today's application landscape, data is the lifeblood, but it's often fragmented across dozens of sources: relational databases, NoSQL stores, third-party services, and internal APIs. For developers, this creates a constant challenge: how do you efficiently and securely query this data without writing tangled, brittle code?

Enter a new paradigm: Intelligent Search, Delivered as Code.

Searches.do is an agentic workflow platform designed to solve this very problem. It allows you to build, deploy, and manage intelligent search and data retrieval agents, transforming complex logic into simple, powerful, and reusable APIs.

This guide will walk you through the core concepts of Searches.do and show you how to build your first intelligent data query.

What is an Intelligent Search Agent?

Before we dive in, let's clarify what we mean by an "agent." Think of a search agent as a specialized, autonomous unit of code dedicated to a single data retrieval task. It's more than just a function or a SQL query; it's a complete package that encapsulates:

• The Connection: The credentials and logic to connect to a specific data source (a database, an API, etc.).
• The Logic: The steps needed to find, filter, aggregate, or transform the data. This is your business logic, defined as code.
• The Interface: A clean, simple API endpoint that accepts parameters and returns a predictable result.

By using this agentic workflow, you decouple your main application from the complexities of your data sources. Your app no longer needs to know how to talk to the customer database; it just needs to ask the find-customer agent for the data it needs.

Building Your First Agent: Finding a Customer

Let’s walk through a classic developer task: retrieving a customer's profile from a database using their email address.

Step 1: Define the Goal as "Business-as-Code"

On the Searches.do platform, you'd start by creating a new agent. We'll name it find-customer-by-email. This name isn't just a label; it's the unique identifier we'll use to call our agent later.

Inside the agent's configuration, you define the search logic. This is "Business-as-Code" in action. You might:

1. Configure the Data Source: Securely provide the connection details for your production database. These credentials are encrypted and stored by Searches.do, never exposed to your client application.
2. Write the Query: Define the SQL query to be executed.

   SELECT id, first_name, last_name, email, created_at
   FROM customers
   WHERE email = ?;
   

3. Map the Inputs: Specify that the ? in your query corresponds to an input parameter named email that the agent will receive.

Step 2: Deploy the Agent as a Search API

With the logic defined, you deploy the agent. Instantly, Searches.do provisions a secure, scalable endpoint for your agent. You've just turned a raw database query into a fully-managed search API without writing a single line of backend server code, managing infrastructure, or worrying about security vulnerabilities like SQL injection (since the query structure is pre-defined).

Consuming Your New Search API

Now for the fun part. With your agent live, you can call it from any application using the Searches.do client library. The complexity of the database connection and query is completely abstracted away.

Here’s how you’d use our find-customer-by-email agent in a TypeScript application:

import { createClient } from 'searches.do';

// Initialize the client with your API key
const searches = createClient(process.env.DO_API_KEY);

// Effortlessly run a pre-defined search agent
async function findCustomer(email: string) {
  try {
    const customer = await searches.run('find-customer-by-email', {
      email: email
    });

    console.log('Found customer:', customer);
    return customer;
  } catch (error) {
    console.error('Failed to retrieve customer:', error);
  }
}

findCustomer('jane.doe@example.com');

Let's break that down:

• Initialization: You securely initialize the client with your API key.
• searches.run(...): This is the magic. You simply call the run method with the agent's name (find-customer-by-email) and an object containing the required parameters ({ email: '...' }).

The result is clean, readable, and incredibly powerful. Your application code is now focused on what it needs (the customer data), not how to get it.

Why This Approach is a Game-Changer

Adopting an agentic workflow for data retrieval offers profound benefits beyond just cleaner code.

• Rock-Solid Security: By creating a dedicated API for each search, you prevent direct database access from your applications. This drastically reduces the risk of accidental data leaks or injection attacks and provides a central point for auditing and access control.
• Effortless Maintainability: Database schema changed? A third-party API was updated? No problem. You only need to update the agent in your Searches.do dashboard. Your application code remains untouched.
• Infinite Flexibility: This pattern isn't just for finding records in a database. You can create agents to:
  • Aggregate data from multiple sources for a BI dashboard.
  • Generate a complex report and return it as a PDF.
  • Query a vector database for semantic search results.
  • Validate user input against a third-party service.

Get Started Today

You've just seen how to transform a standard data query into a secure, scalable, and simple intelligent search API. By treating your data retrieval logic as code and packaging it into agents, you can build faster, more secure, and more maintainable applications.

Ready to stop wrestling with data sources and start building smarter?

Sign up on Searches.do and deploy your first agent in minutes.