Forem: Tilde A. Thurium

How to use your network to get a job

Tilde A. Thurium — Mon, 13 Oct 2025 17:26:06 +0000

Common advice for job seekers is to "use your network" but what does that mean, exactly? Let's break it down.

In 2025, job referrals are everything

As a hiring manager, I got hundreds of applicants within 24 hours of posting a new job. Most of the applications were AI slop. Recruiters and managers are overwhelmed.

A personalized referral from someone you know will get you further with a hiring manager than the perfect resume.

Use your network to get referrals. By network, I mean people you already have a relationship with, who can vouch for your awesome work.

Going to meetups to chat up strangers who are probably also job seeking is likely not the highest-value use of your time.

How to ask for referrals

People want to help you. But first, you need to ask. To the LinkedIn mobile, Batman.

Identify jobs that are a good fit with what you're seeking.
Do some LinkedIn snooping to see if anyone you know works at those companies.
Write those people a quick message asking if they'd be comfortable referring you.

Isn't it weird to ask for a favor when you haven't seen someone in years?

In a professional context, it's totally okay to message an old co-worker you haven't talked to since 2019 and ask for a referral.

Example note to ask for a referral

Hi Tilde!

Long time no see, hope you're doing well.

I saw that LaunchDarkly is hiring for a Backend Engineer, Metrics. [INSERT LINK TO SPECIFIC POSTING]. I have 2 years of experience working on Go backends in my previous company. Would you mind referring me for this role? My resume is attached. Thanks so much!

What works about this letter:

It's brief
It specifies why you're a good fit for the role
It includes all the information needed to make the referral. Nobody has time for a scavenger hunt.

Caveats

Using your network is much harder for early-career engineers. There are many less junior positions available than there used to be. Also, juniors generally have smaller networks to begin with.

Norms vary geographically. I've seen this approach work in North America and European companies. Outside those zones, your mileage may vary.

Parting thoughts

The best time to grow your network is before you need it. If you are currently employed, take the time to celebrate your teammates' wins. Ask people how they are doing. Talk about the excellent work you are doing. Smash that connect button on LinkedIn. Small actions pay off over time in the long run.

The job market is incredibly tough, but people want to help. Go forth and ask.

P.S. LaunchDarkly is hiring.

Snowflake Cortex Completion API + LaunchDarkly SDK Integration

Tilde A. Thurium — Mon, 25 Aug 2025 18:18:23 +0000

This tutorial walks through an integration between the Snowflake Cortex Completion API and LaunchDarkly's AI SDKs. We'll be using a Snowflake Personal Access Token to query the Cortex API and receive completion responses.

Leveraging Snowflake's gateway approach to completions alongside LaunchDarkly's ability to make runtime changes to AI Configs, you can update the models, prompts, and parameters that you're using in the Snowflake endpoints in real-time.

This tutorial is presented in TypeScript, but since we're using Snowflake's REST API it's universal to any language in which you can access Snowflake. Snowflake additionally has a Python package that can be used to access their AI and ML functions.

Authenticate with Snowflake

If you are new to Snowflake, there is some setup you'll need to do to get an application running, like setting up a user that is able to access the API.

Head into your Snowflake instance and follow the guide provided by Snowflake for authenticating against the REST API, and the guide for authenticating against the Cortex REST API.

Pay attention to:

It's recommended to create a new user to access the API so that its permissions, privileges and access can be limited to the necessary scope
Make sure to grant the role of the user you're authenticating as a SNOWFLAKE.CORTEX_USER database role if it's not already present
If you are using a Personal Access Token, make sure to apply a Network Policy that allow-lists the IP you'll be accessing from

Admin Privileges Required for Network Policies

You need admin privileges to create Network Policies for Personal Access Token authentication. If you don't have admin access:

Create a fresh Snowflake trial account (where you'll have admin access)
Or contact your Snowflake administrator for help with authentication setup
Enterprise/work accounts typically don't grant these privileges to regular users
Capture your account identifier, which can be found by accessing the lower-left button on the UI that contains your name and account role.
- Click your name
- Hover over your active account
- In the popover menu, select "View account details"
- Copy the field labeled "Account/Server URL"

Set up an AI Config

Before we write any code, we'll go into LaunchDarkly and create an AI Config to be used in the integration.

Navigate to your LaunchDarkly instance and follow these steps:

Navigate to "AI Configs" and click "Create AI Config" on the top-right side

Give your Config a name, and then select "Cortex" from the provider dropdown.

Now that Cortex is selected, the model dropdown will be filtered to the available models. For this first variation, we'll select claude-3-5-sonnet

Make sure that the region you're accessing from has support for the model you select. You can view model availability on this page.

Add your messages for the completion. We'll add a single system message, as well as a template for where the user message will go:

{{variables}} signify a variable that will be replaced at the time you retrieve your config. This is how you provide dynamic content to your Configs such as contextual user information

Click "Review and save". You'll be given a chance to review your changes before committing them.

Your AI Config is now saved so it's time to serve our new variation to our users. Click the "Targeting" tab on the top of the AI Config:

By default your Config will be serving the disabled variation which is used to signal that a Config is turned off. We'll revisit this aspect later in the code.

Click "Edit" on the default rule and select your variation from the dropdown, click "Review and save", and then confirm the changes:

You've now targeted a variation which can be served in the SDK. We'll come back to this later once we've got some code set up. For now, just copy the key in your sidebar for later:

Set up the server

Next, we'll set up our sample application so that we can see LaunchDarkly AI Configs and the Snowflake REST API interacting in real-time. This section assumes some knowledge with TypeScript and the NodeJS ecosystem, but can be accomplished in any language with AI SDK support.

For the following sections, these are instructions to set it up as a new application. If you're not concerned about which piece does what or having a clean slate, you can also just clone this repository and run npm install and then npm run start after filling out the .env section.

Set up an ExpressJS application

Follow the ExpressJS installation guide to set up a new project leveraging Express.

Basic setup

Let's create some of the structure we'll need for the app:

mkdir app views
touch index.ts package.json views/index.html app/launchdarklyClient.ts app/completions.ts
cp .env.example .env

`.env`

The last command created a .env file that we'll use to register our secrets so they can be securely loaded by the application.

Within this file, fill out the following values:

SNOWFLAKE_ACCOUNT_IDENTIFIER=<Snowflake account identifier>.snowflakecomputing.com
SNOWFLAKE_PAT=<Snowflake Personal Access Token>

LAUNCHDARKLY_SDK_KEY=<LaunchDarkly SDK key>
LAUNCHDARKLY_AI_CONFIG_KEY=<LaunchDarkly AI Config key>
PORT=3000

The Snowflake account identifier and Personal Access Token should be available from following the authentication instructions for Snowflake.

If you do not know how to get your LaunchDarkly SDK key, you can follow this guide.

`package.json`

Grab the contents of the package.json file from the repository and replace your local package.json file.

Now run npm install to install our dependencies. Once that finishes, run typescript --init from the project folder to create a tsconfig.json file. You'll need the dependencies in here to process TypeScript files and run your local application.

The dependencies in this file do the following:

Add TypeScript support to ExpressJS (@types/express, typescript)
Add utilities to run the application (nodemon, ts-node, dotenv)
Initialize the LaunchDarkly SDKs (@launchdarkly/node-server-sdk, @launchdarkly/server-sdk-ai)

We are using default TypeScript settings. Feel free to edit these to match your project's needs.

`index.ts`

The index.ts file is responsible for initializing the application. We'll be including two routes; one to render an HTML page and one to respond to the completion.

Grab the index.ts file from the repo and replace this content. The file has comments explaining the functionality.

`index.html`

Replace the index.html file in views/index.html with the same content from the repository, or use it as a guideline to build your own interface for the chat. This file is also commented, but outside of the HTML structure, you'll want to pay attention to the <script> at the bottom of the page which handles making the API call.

Make our completion calls

Now that we have an application, we can start wiring up LaunchDarkly to the Snowflake API.

We'll set up the LaunchDarkly clients in app/launchdarklyClient.ts:

import { LDClient, init } from "@launchdarkly/node-server-sdk";
import { LDAIClient, initAi } from "@launchdarkly/server-sdk-ai";

let ldClient: LDClient;
function getSDKClient() {
    if (!ldClient) {
        ldClient = init(process.env.LAUNCHDARKLY_SDK_KEY!);
    }

    return ldClient;
}

let aiClient: LDAIClient;
function getAIClient() {
    if (!aiClient) {
        aiClient = initAi(getSDKClient());
    }
    return aiClient;
}

// Initialize and return the LaunchDarkly client
export async function getLaunchDarklyClients() {
    const ldClient = getSDKClient();
    const aiClient = getAIClient();

    try {
        await ldClient.waitForInitialization({ timeout: 10 });
    } catch (err) {
        // log your error.
    }

    return { ldClient, aiClient };
}

export async function closeLaunchDarklyClients() {
    await ldClient.flush();
    ldClient.close();
}

The LaunchDarkly AI SDK allows you to use the features of AI Configs within the LaunchDarkly SDK.

Within app/completions.ts let's go ahead and set up the Snowflake call:

import { getLaunchDarklyClients } from './launchdarklyClient';
// Base URL
const SNOWFLAKE_BASE_URL = `https://${process.env.SNOWFLAKE_ACCOUNT_IDENTIFIER}`
// Completion endpoint
const SNOWFLAKE_COMPLETE_URL = `${SNOWFLAKE_BASE_URL}/api/v2/cortex/inference:complete`

const snowflakeCompletionClient = async (body: Record<string, any>) => {
    const headers = {
        'Content-Type': 'application/json',
        // Includes the authorization token on the request
        'Authorization': `Bearer ${process.env.SNOWFLAKE_PAT}`,
        'Accept': 'application/json'
    }
    // Run a fetch on the Snowflake completion URL
    return fetch(SNOWFLAKE_COMPLETE_URL, {
        method: 'POST', 
        headers,
        // We are not going to stream our responses, so pass `stream:false` to all instances of this invocation
        body: JSON.stringify({...body, stream: false}),
    })
}

export async function runSnowflakeCompletion(userInput: string) {
    // Retrieve the AI Client from LaunchDarkly
    const { aiClient } = await getLaunchDarklyClients();
    // Set up the user's context; this can be used to control which variations the users receive. You can target against any attribute passed in this context.
    const userContext = {
        type: 'user',
        name: 'John Doe',
        key: `user-${Math.random().toString(36).substring(2, 15)}`
    }
    // Retrieve the AI Config from the LD SDK
    const config = await aiClient.config(
        // This is the key of our config
        process.env.LAUNCHDARKLY_AI_CONFIG_KEY!, 
        // Context
        userContext, 
        // Defaults - can be left empty unless you want to provide
        // default values if the AI Config is not found.
        {}, 
        // These variables are automatically interpolated into the 
        // messages returned from the SDK. Here, we're providing the
        // user's actual query, but this can be used for other runtime data augmentation purposes
        { userInput }
    )
    // Check that the config is enabled and conforms to the shape we would expect.
    // Some calls may omit things like the `messages` array when just changing models.
    if(!config.enabled || !config.model || !config.messages) {
        throw new Error("Malformed config")
    }
    // Make the call to the Snowflake API
    const run = await snowflakeCompletionClient({
        // The model name is provided dynamically, which means we
        // can change this at runtime with AI Configs!
        model: config.model.name,
        messages: config.messages,
    })

    const result = await run.json();
    // Extract the top choice of message and return it to the client
    const response = result.choices?.[0]?.message.content ?? "No response from Snowflake"

    return { response, model: config.model.name };
}

Run the app

Navigate to your root directory and run npm run start to start the application.

When you navigate to localhost:3000 (or whichever port you changed it to) you should see a simple screen that looks like this:

Enter a query into the textarea, such as "How do I create a user in Snowflake?" and after a few moments a response will be generated:

We can see in the response that it lists the model we're using to generate the completion.

Make runtime changes

Now that we have a completion endpoint set up, let's create a new variation and change the model at runtime. You can minimize your code editor for now; we'll only need to make changes in the LaunchDarkly UI!

Navigate back to your AI Config in the LaunchDarkly UI
Click "Add another variation" and then repeat the steps from earlier, but this time select a different model. We'll use llama3.1-8b and edit the system message slightly for tone:

Click save and head back over to targeting
On the targeting page, edit the default rule and select the new variation you created:

Click save and confirm the changes

Now, let's head back over to our app on the localhost URL. Without refreshing the page or restarting the server, go ahead and re-submit the request.

Our output was now generated by our llama3.1-8b model rather than the Sonnet model we were leveraging earlier:

And that's it! We've now made a runtime model change on an active AI Config.

We didn't have to change any code to change the model, and there's more we can tweak such as the model's parameters and messages. We can add messages and have them automatically inserted at runtime, test different models on different customers, and tweak parameters in a live system to see how the models respond in real-world conditions.

The last point we'll touch on is how we can optionally capture data about our AI Config invocations and send those over to LaunchDarkly.

Setting up monitoring

To set up monitoring, we need to extract the tracker object from our AI Config and call some track methods that will communicate the metrics to LaunchDarkly.

Let's update the app/completions.ts file to include tracking:

import { LDAIConfigTracker } from '@launchdarkly/server-sdk-ai';
import { getLaunchDarklyClients } from './launchdarklyClient';
// Base URL
const SNOWFLAKE_BASE_URL = `https://${process.env.SNOWFLAKE_ACCOUNT_IDENTIFIER}`
// Completion endpoint
const SNOWFLAKE_COMPLETE_URL = `${SNOWFLAKE_BASE_URL}/api/v2/cortex/inference:complete`

const snowflakeCompletionClient = async (body: Record<string, any>) => {
    const headers = {
        'Content-Type': 'application/json',
        // Includes the authorization token on the request
        'Authorization': `Bearer ${process.env.SNOWFLAKE_PAT}`,
        'Accept': 'application/json'
    }
    // Run a fetch on the Snowflake completion URL
    return fetch(SNOWFLAKE_COMPLETE_URL, {
        method: 'POST', 
        headers,
        // We are not going to stream our responses, so pass `stream:false` to all instances of this invocation
        body: JSON.stringify({...body, stream: false}),
    })
}

export async function runSnowflakeCompletion(userInput: string) {
    // Retrieve the AI Client from LaunchDarkly
    const { aiClient } = await getLaunchDarklyClients();
    // Set up the user's context; this can be used to control which variations the users receive. You can target against any attribute passed in this context.
    const userContext = {
        type: 'user',
        name: 'John Doe',
        key: `user-${Math.random().toString(36).substring(2, 15)}`
    }
    // Retrieve the AI Config from the LD SDK
    const config = await aiClient.config(
        // This is the key of our config
        process.env.LAUNCHDARKLY_AI_CONFIG_KEY!, 
        // Context
        userContext, 
        // Defaults - can be left empty unless you want to provide
        // default values if the AI Config is not found.
        {}, 
        // These variables are automatically interpolated into the 
        // messages returned from the SDK. Here, we're providing the
        // user's actual query, but this can be used for other runtime data augmentation purposes
        { userInput }
    )
    // Extract the tracker from the AI Config
    const { tracker } = config;
    // Check that the config is enabled and conforms to the shape we would expect.
    // Some calls may omit things like the `messages` array when just changing models.
    if(!config.enabled || !config.model || !config.messages) {
        // Track an error if the config is not enabled or does not conform to the shape we would expect.
        tracker.trackError();
        throw new Error("Malformed config")
    }
    try {
        const durationStart = Date.now();

        // Make the call to the Snowflake API
        const run = await snowflakeCompletionClient({
            // The model name is provided dynamically, which means we
            /// can change this at runtime with AI Configs!
            model: config.model.name,
            messages: config.messages,
        })

        const durationEnd = Date.now();

        const result = await run.json();
        // Track a successful completion
        tracker.trackSuccess();
        // Track the duration of the completion
        tracker.trackDuration(durationEnd - durationStart);
        // Track the tokens used in the completion
        if (result.usage) {
            tracker.trackTokens({
                total: result.usage.total_tokens,
                input: result.usage.prompt_tokens,
                output: result.usage.completion_tokens,
            });
        }

        // Extract the top choice of message and return it to the client
        const response = result.choices?.[0]?.message.content ?? "No response from Snowflake"

        return { response, model: config.model.name };
    } catch(error) {
        // An error occurred while making the completion call
        tracker.trackError();
        throw error;
    }

}

We now capture a duration by setting a timer before and after the call, and use the usage parameter returned from Snowflake to capture the token usage. These metrics will appear in your dashboard for your AI Config under the "Monitoring" tab:

You'll receive additional information on this page about when different variations released and when changes were made to the configs so that you can keep track of what changes have what impact on your completions.

Wrapping up

This is a simple example but demonstrates how you can use the power of Snowflake's Cortex completion gateway in conjunction with AI Configs. Together, they allow you to tweak models in real-time by selecting any models available in your region and having them update seamlessly without requiring any code changes.

Additionally, with the power of LaunchDarkly's targeting you can serve different models and prompts to different users, and even run experiments against your AI Configs to see which model and prompts best fit your features.

To get started with AI Configs, sign up for a free trial. You can also contact us at aiproduct@launchdarkly.com with any questions.

Originally published by Andrew Klatzke on docs.launchdarkly.com.

Using LaunchDarkly's AI Configs to review database changes

Tilde A. Thurium — Thu, 21 Aug 2025 19:43:01 +0000

Overview

At LaunchDarkly, we’re constantly pushing the boundaries of what it means to move fast without breaking things. We ship frequently, serve quadrillions of events per day, and operate with zero tolerance for downtime. To keep pace, we need systems that help us ship confidently—even when change is happening at a rapid, “vibe coding” pace.

But what happens when that rapid change reaches your database?

From an SRE’s perspective, the database is sacred. It’s the source of truth—and one of the riskiest areas to touch without deep context. Even if your code is reviewed in a pull request:

Does the reviewer understand the query access patterns?
Could this schema change hurt index performance?
Is the change touching critical production tables?
Will the new model scale with usage?

With LaunchDarkly AI Configs, we finally have a way to automate this kind of insight — reviewing database changes before they become production issues.

Prerequisites

To follow along, you'll need:

A LaunchDarkly account with AI Configs enabled. Sign up for free here..
Access to a database system. These code samples are written to be compatible with a database using the PostgreSQL wire protocol. However, you could adapt them to suit other flavors of databases.
Basic familiarity with SQL and database schema management
A development environment where you can test database changes

What are AI Configs?

LaunchDarkly AI Configs allow you to customize, test, and roll out new large language models (LLMs) within your generative AI applications.

🧠 What the AI Reviewer Checks

Our system uses LaunchDarkly’s internal AI Configs to analyze your schema and query changes directly from a CI build. It checks for:

Are the queries optimized for access patterns?
Are the right indexes in place?
Are we modifying high-risk tables?
Will the schema scale and evolve over time?

This isn’t just a linter. It’s an AI-powered reviewer trained on your environment.

If you want to skip right to reading the code, a complete example can be found here.

## 🛠 Step 1: Collect the Right Data

The AI needs a complete snapshot of your system to make a meaningful review:

Full schema (full-schema.json)
Schema diff (schema-diff.json)
Full set of SQL queries (sql-queries.json)
Query diff (queries-diff.json)

📦 sql-proxy container

To evaluate database changes, we need to observe real SQL queries your application runs during CI.

We do this by inserting a lightweight PostgreSQL proxy between your app and the database. It logs and deduplicates queries, then exposes them via an API for analysis.

Here’s the setup in Docker Compose / GitHub Action Service Container:

services:
  postgres:
    image: postgres
    env:
      POSTGRES_PASSWORD: postgres
    ports:
      - 5432:5432

  proxy:
    image: ghcr.io/${{ github.repository_owner }}/sql-proxy:latest
    env:
      LISTEN_PORT: 5433
      BACKEND_HOST: postgres
      BACKEND_PORT: 5432
      API_PORT: 8080
      DB_CONNECTION_STRING: host=postgres port=5432 user=postgres password=postgres sslmode=disable
    ports:
      - 5433:5433
      - 8080:8080

Every query is deduplicated and exposed via:
GET http://localhost:8080/queries

Connecting to the database via 5433 will now pass the queries through the proxy.

🏗 Dumping the Schema

To give the AI full context, we also need a snapshot of the database schema—including table definitions, columns, indexes, and relationships.

This can be triggered early in the CI pipeline to run in parallel with your other steps:

- name: Migrate Database
  run: |
    cd schema_test
    go run .

- name: Start Schema Dump
  run: |
    curl -X POST http://localhost:8080/schema_dump

⏱️ Note: For large schemas, this can take a minute or two. Triggering it early(but after the migrations) avoids blocking downstream jobs.

📊 Step 2: Compare Against Main

After your tests or migrations run through the proxy, it now holds:

The full set of SQL queries the app executed
The current state of the database schema

With this data captured, you can run a GitHub Action that:

Calls the proxy’s API to fetch the captured data
Downloads artifacts from the main branch (last known good state)
- Note: it needs to run on the main branch at least once to have generated a proper artifact for comparison
Compares current vs. main to generate:
- schema-diff.json
- queries-diff.json

Here’s what that looks like in CI:

- name: Get SQL Data
  uses: droptableifexists/recon@main
  id: get-sql-data
  with:
    SQL_PROXY_API_ADDRESS: localhost:8080
    GITHUB_REPOSITORY: ${{ github.repository }}
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

🤖 Step 3: Run the AI Review

After you have the four key files, you pass them into the AI Config system.

Save input to a file:

- name: Save SQL data to file
  run: |
    cat << EOF > analysis_input.json
    {
      "sql_queries": ${{  toJSON(steps.get-sql-data.outputs.sql-queries) }},
      "queries_diff": ${{  toJSON(steps.get-sql-data.outputs.queries-diff) }},
      "schema": ${{  toJSON(steps.get-sql-data.outputs.schema) }},
      "schema_diff": ${{  toJSON(steps.get-sql-data.outputs.schema-diff) }}
    }
    EOF

Run the DB analysis tool:

- name: Run Database Analysis
  uses: launchdarkly-labs/lddbai@main
  with:
    message: "Analyzing database changes..."
    input_file: analysis_input.json
    openai_api_key: ${{ secrets.OPENAI_API_KEY }}
    launchdarkly_sdk_key: ${{ secrets.LAUNCHDARKLY_SDK_KEY }}
    github_token: ${{ secrets.GITHUB_TOKEN }}
    pull_request_number: ${{ github.event.pull_request.number }}

Under the hood, here's what the code looks like:

def get_ai_config(payload: dict) -> tuple[AIConfig, LDAIConfigTracker]:
   aiclient = Deps().get_launchdarkly_ai()
   context = Context.builder('cockroachdb').kind('database').name('cockroachdb').build()
   fallback_value = AIConfig(
       enabled=True,
       model=ModelConfig(name="gpt-4o-mini", parameters={"temperature": 0.8}),
       messages=[LDMessage(role="system", content="")],
       provider=ProviderConfig(name="my-default-provider"),
   )
   return aiclient.config('evaluate-database-changes', context, fallback_value, {
       'schema': payload.get('schema', []),
       'schema_diff': payload.get('schema_diff', []),
       'sql_queries': payload.get('sql_queries', []),
       'queries_diff': payload.get('queries_diff', [])
   })

And to get the AI’s recommendation:

def get_ai_recommendation(payload: dict) -> str:
   config, tracker = get_ai_config(payload)
   messages = [] if config.messages is None else config.messages
   response = tracker.track_openai_metrics(
       lambda: client.chat.completions.create(
           model=config.model.name,
           messages=[message.to_dict() for message in messages],
       )
   )
   Deps().get_launchdarkly().flush()
   return response.choices[0].message.content

🧠 Step 4: Add Context That Only You Know

Once the model has your queries and schema, you can make it smarter by adding business context:

Database engine and version 🧱
Critical tables to tread carefully around 🚨
Average query volume and server specs 📈
Team-specific data modeling principles 📐
History of past incidents or patterns 📜

This context transforms the AI from a generic reviewer into a tailored risk advisor for your system.

🚀 Why This Matters

With AI Configs, you can:

Catch performance and scaling issues before they hit production
Share SRE intuition across your whole engineering team
Shorten feedback loops without blocking deploys
Scale database expertise without bottlenecks

You’re no longer at the mercy of “who reviewed the PR.” Every change gets a consistent, context-aware review.

🏁 Final Thoughts

Database changes don’t have to be scary anymore.

By plugging into LaunchDarkly AI Configs, you can automate reviews, enforce data modeling best practices, and de-risk your deploys—without slowing anyone down. To get started, sign up for a free trial today or email us at aiproduct@launchdarkly.com if you have questions.

So yeah, go ahead. Vibe out. Ship confidently. And let the AI handle the hard stuff.

Originally published by Kevin Kruger on the LaunchDarkly blog.

4 hacks to turbocharge your Cursor productivity

Tilde A. Thurium — Wed, 11 Jun 2025 15:22:57 +0000

Cursor, an AI code editor, is the fastest growing developer tool of all time, at least according to spearhead.co.

Cursor works pretty well out of the box, but there's a lot you can do to make it even better. In this post we'll cover four tips to make your Cursor agent more accurate, personalized, and better integrated with other developer tools.

If you haven't installed Cursor, follow the installation instructions here.

Tip #1: Add developer documentation as a data source

The more context an AI agent has, the better its suggestions will be. Generative model training data can be frozen months or years before the models are released to the public. This lag makes it hard for models to generate up-to-date code reflecting the latest changes to software libraries. Fortunately, you can add documentation to Cursor to enhance the coding agent's abilities and reduce hallucination.

If you add a root documentation link to Cursor, it will index the content of those docs, including child links. When you make queries to the AI agent, the AI agent will determine if those docs are relevant, using vector similarity search. Relevant docs will be used to generate a higher quality response to your query.

Cursor comes with documentation for many popular libraries already indexed. You can add documentation about specific libraries, tools, and SDKs you use in your codebase.

For example, I'll show you how to add the LaunchDarkly docs. In Cursor, go to Settings > Cursor Settings > Indexing & Docs. Click Add Doc.

In the following dialog box, paste in the URL of the docs you'd like to add:

Click Add Docs.

For better or for worse, software is never complete; thus, documentation is always in flux too. Cursor periodically reindexes any docs you have added. You can manually reindex by clicking the curved arrow icon in Settings > Cursor Settings > Indexing & Docs. You can also remove docs that are no longer relevant by clicking the trash icon.

Tip #2: Use MCP to interact with APIs in plain English

Model-context protocol (MCP) is an open protocol that lets you interact with APIs using natural language.

For example, the LaunchDarkly MCP server lets you manage LaunchDarkly feature flags and AI Configs from within your IDE, in plain English.

Warning: You can currently only have 40 tools (or functions) installed at the same time, across all the MCP servers that are currently running. This limitation exists because while LLM context windows are expanding, they aren't boundless. Adding and removing MCP servers doesn't take too long, so you can tinker with what servers are installed locally depending on the needs of your current engineering project. Developers are racing to build middleware layer that solves this problem, so it's likely this pain point is temporary.

How can you discover what MCP servers might be the most useful to you? MCP server registries are multiplying almost as fast as MCP servers. However, the most complete registry lives on the official modelcontextprotocol GitHub organization.

Tip #3: Use Cursor rules as system-level context

Cursor rules allow you to provide additional instruction to the coding agent. They are handy for specifying domain-specific knowledge.

The rules are flexible enough that you can indicate when you want them to be attached to a query. The options are:

Always: Be careful with this one, it can take up valuable context tokens for things that don't need to be included in every request.
Auto Attached: You can instruct Cursor to auto-attach the rule when editing files matching a specific *.extension.
Agent Requested: Describe the kinds of tasks the rule is helpful for, and the Cursor Agent will decide if the rule should be applied.
Manually: You can manually add the rules to the context in your chat window with the AI agent.

Rules are written in Markdown. If you want to see an example of what they looks like in practice, this repository contains recommended Cursor rules for LaunchDarkly development.

You can share project-level rules with other developers on your team by committing them to a settings directory in a shared repository.

Using Cursor rules for personalization

In addition to project-level rules, Cursor also supports user-level rules which can be useful for personalizing your experience. Perhaps you find the AI agent's egregious overuse of exclamation points to be a bit much. You can add a Cursor rule to tone down the enthusiasm to a more manageable level.

When responding to queries, use a dry, matter-of-fact tone.

On the more unhinged end of the spectrum, you can try ramping up the absurdity:

Provide all code feedback in the form of a roast.

Tip #4: Pick the model that's best for your use case

Engineering is fundamentally about making tradeoffs. Model selection requires balancing quality, latency, and cost to suit your use case.

If you have an easier task to do, consider using a lighter-weight model. I find that Claude 3.5 Sonnet meets my everyday coding needs. Reasoning models with larger context windows such as OpenAI's o3 are more expensive, so consider saving those for gnarlier problems.

You can change your model in Settings > Cursor Settings > Models. Usage details currently live in Settings > Cursor Settings > General Manage Account.

New models are released daily. Keeping up to date is a struggle. For the latest info on model availability, see Cursor's documentation.

Conclusion

To get the most out of your Cursor experience:

Add technical documentation as a data source for the Cursor agent.
Add Cursor rules to provide system-level guidance on domain specific knowledge, or personalization.
Install MCP servers locally to make interacting with your most-used APIs a breeze.
Consider what size model best fits your use case.

Thanks for following along! If you have any questions, or you want to tell me about your favorite MCP servers, you can reach me via email (tthurium@launchdarkly.com), Bluesky, Discord, LinkedIn, or in the comments below.

Create a feature flag in your IDE in 5 minutes with LaunchDarkly’s MCP server

Tilde A. Thurium — Tue, 03 Jun 2025 21:05:22 +0000

You can now create, evaluate, and modify flags from within your IDE or AI client using natural language with LaunchDarkly's new MCP server. Follow along with this tutorial for step by step instructions.

This MCP server is currently in beta. For the most up to date instructions, read about the LaunchDarkly MCP server in the official product documentation.

Prerequisites

In order to complete this tutorial, you must have the following prerequisites:

A LaunchDarkly account. Sign up for a free one here.
The Cursor IDE installed on your local machine. Although this tutorial is Cursor-focused, our MCP server also works with any AI client that supports MCP, such as Windsurf or even Raycast.
A JavaScript runtime on your local machine that supports ECMAScript 2020 or newer. Functionally, this means Node.js v18 or v20, Bun v1 or newer, or Deno 1.39 and above.

What is MCP?

Model-context protocol (MCP), is an open protocol that lets you interact with APIs using natural language.

LaunchDarkly's MCP server is powered by Speakeasy, a developer tool for generating SDKs, documentation, and agent tools.

Creating a LaunchDarkly API access token

To use the LaunchDarkly MCP server, you'll need to create a LaunchDarkly API access token with appropriately scoped permissions.

Go to the the LaunchDarkly Authorization page. (If you're an EU or Federal user, that link won't work – instead, navigate to Organization settings > Authorization in the left nav menu.) Click Create token. Give the token a memorable name, such as "Tilde's MCP server." The Role should be Writer. Leave the service token box unchecked. The MCP server will be running on your local machine, so a personal API token is a better fit. Also, leave the API version set to the most recent version (currently 20240415).

After you create your API token, copy it to your clipboard. You'll need it for the next step. After you leave the page the token will be hidden, so don't lose it.

Installing the MCP server

Here's a deeplink to install the LaunchDarkly MCP server directly in Cursor. Replace the api key with your LaunchDarkly API access token.

If that doesn't work for some reason, open Cursor. Go to Settings > Cursor Settings > MCP > Add a new MCP server.

Copy the example configuration, using your API token instead of the dummy key in this example.

{
  "mcpServers": {
    "LaunchDarkly": {
      "command": "npx",
      "args": [
        "-y", "--package", "@launchdarkly/mcp-server", "--", "mcp", "start",
        "--api-key", "api-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
      ]
    }
  }
}

If you're using LaunchDarkly's Federal or EU instances, you'll need to point your server at a different host by adding a server-url argument like so. Replace <host> with your host URL.

{
  "mcpServers": {
    "LaunchDarkly": {
      "command": "npx",
      "args": [
        "-y", "--package", "@launchdarkly/mcp-server", "--", "mcp", "start",
        "--api-key", "api-xxxxxxx",
    "--server-url", "<host>"
      ]
    }
  }
}

Creating a feature flag with MCP

Toggle Cursor's AI pane. Try asking the agent to create a flag using the following prompt:

create a feature flag to gate my awesome new feature

Model responses are non-deterministic, so your response may not exactly match the following, but it should be something like this:

To create a feature flag for your awesome new feature, I'll need to know which LaunchDarkly project you want to add the flag to. Could you please provide the project key (the unique identifier for your LaunchDarkly project)? If you have a preferred flag key or description, let me know as well, or I can generate them for you!

Oops, we forgot to specify which LaunchDarkly project we wanted to use. Luckily the agent retains context between queries, and knows how to ask us for the info it needs. The MCP protocol is forgiving and you don't have to get prompts perfect on the first try.

My example LaunchDarkly project is named raccoon-api-facts. 🦝 Don't judge me. Input your own project name in the AI chat pane and hit Enter. Although these flag and project names are technically called keys when referenced in code, the LaunchDarkly MCP server can understand what we are asking for without that level of specificity. Hooray for natural language interfaces.

Click Run tool in your AI pane in Cursor to finish creating the flag. You'll need to do this every time the AI agent attempts to interact with the LaunchDarkly API. MCP servers require explicit approval before calling external APIs as a security measure.

Next, roll over to the LaunchDarkly UI. You should see the awesome-new-feature flag in your list. If it's not there, double-check that you're in the correct project.

Back in Cursor, if you click on called MCP tool you can see the details of the request the MCP server sent to the LaunchDarkly API:

Enabling a feature flag

Ask the AI agent to check the value of the flag:

what is the value of the awesome-new-feature flag?

Your response should be something like this:

The value of the awesome-new-feature flag is currently set to off (false) by default in both the production and test environments. If you want to enable it or check its value for a specific user or context, let me know!

This matches what we see in the LaunchDarkly UI:

Let's try to turn the flag on and see what happens!

Turn the awesome new feature flag ON, serving True to all users.

Don't forget to click Run tool after submitting your prompt to the agent.

The awesome-new-feature flag is now turned ON in both the production and test environments! Your awesome new feature is now enabled for all users in these environments.

If you want to target specific users, add rules, or need to verify the flag's status, just let me know!

You may need to reload the LaunchDarkly UI in your browser to see the updated flag state:

![Screenshot of flag configuration in the LaunchDarkly UI. The flag is On, serving true to all users in the Production environment.

Adding a flag targeting rule

What if we ask the AI agent to do something a little more complicated? Let's create a targeting rule so that the flag is serving true for users whose email addresses end in launchdarkly.com. This could be useful if we wanted to roll out our awesome new feature to internal users first, to test for bugs.

For the awesome new feature flag, update the targeting rules so the flag is only enabled and serving true for users who have email addresses ending with launchdarkly.com. Everyone else should get the false variation.

The awesome-new-feature flag is now enabled only for users whose email addresses end with launchdarkly.com in both production and test environments. For all other users, the flag will be off.

If you need to further adjust the targeting or want to verify the setup, let me know!

Checking the AI agent's work in the LaunchDarkly UI, it looks like the targeting updates were successful:

Evaluating a feature flag

Now that our targeting rule is set up, let's try evaluating our awesome feature flag using a few different contexts.

Evaluate the awesome new feature flag using the following context:
{"name": "tilde", "email": "tthurium@launchdarkly.com"}

To evaluate the awesome-new-feature flag for the context:
{"name": "tilde", "email": "tthurium@launchdarkly.com"}

The flag is ON, but only enabled for users whose email ends with @launchdarkly.com.
The provided email tthurium@launchdarkly.com matches this rule.

Result: The awesome-new-feature flag will be enabled (true) for this user.

If you want to see the raw evaluation or check for a different context, let me know!

Great. What about evaluating a context that should be false?

evaluate the awesome new feature flag using the following context:
{"name": "tilde", "email": "tthurium@foo.com"}

For the context {"name": "tilde", "email": "tthurium@foo.com"}:

The awesome-new-feature flag is ON, but only enabled for users whose email ends with "@launchdarkly.com".
The email tthurium@foo.com does not match this rule.

Result: The awesome-new-feature flag will be disabled (false) for this user. If you want to check for another context or need the raw evaluation details, let me know!

You can even pass in the context in natural language rather than JSON.

Evaluate the value of Awesome New Feature flag with a context where the user has an email address foo@bar.com

Given the current targeting rules for the "Awesome New Feature" flag:

The only users who receive the true variation are those whose email ends with launchdarkly.com.

All other users receive the false variation. For a user with the email address foo@bar.com, the flag will evaluate to false in both the Production and Test environments.

Note that the LaunchDarkly API doesn't have an endpoint for evaluating feature flags. For that, you'd need to use one of LaunchDarkly's SDKs. When you evaluate a feature flag via MCP, the AI model is running the evaluation logic. Cool!

Task	Prompt
Disabling a feature flag	Turn the $FEATURE_FLAG_KEY flag off.
Updating a feature flag description	Update the $FEATURE_FLAG_KEY flag description: "When enabled, show the updated UI for my awesome new feature."
Listing all feature flags in a project	Show me all the feature flags in the $PROJECT_KEY project.
Getting a feature flag's details	Tell me about my $FEATURE_FLAG_KEY feature flag.
Adding individual targets	Add a new targeting rule for the $FEATURE_FLAG_KEY feature flag so that the user `tthurium@launchdarkly.com` receives the true variation.
Copying a feature flag	Create a new feature flag that copies the configuration of the $FEATURE_FLAG_KEY flag, but add V2 to the flag key.
Archiving a feature flag	Archive the feature flag $FEATURE_FLAG_KEY.
Deleting a feature flag. (Be careful with this one — the action can't be undone!)	Delete the feature flag $FEATURE_FLAG_KEY.

Conclusion

In this tutorial you learned how to create and manage feature flags from within your IDE, using the magic of MCP. This can save you time, as well as the mental energy of context switching, which will ultimately help you ship more quickly.

Stay tuned for updates. We're actively working on adding more functionality to our MCP server.

If you enjoyed this tutorial, here's some related reading:

Thanks for following along! If you have any questions, or you want to tell me about the cool stuff you're building, you can reach me via email (tthurium@launchdarkly.com), Bluesky, Discord, or LinkedIn.

Using Jina Embeddings v2 with Haystack 2.0 pipelines to summarize legal documents

Tilde A. Thurium — Wed, 10 Jan 2024 16:31:51 +0000

Jina.ai recently upgraded and expanded the capabilities of their previous embedding model in a v2 release.

With the Jina Haystack extension, you can now take advantage of these new text embedders in your Haystack pipelines! In this post, we'll show what's cool about Jina Embeddings v2 and how to use them.

You can follow along in the accompanying Colab notebook of a RAG pipeline that uses the Jina Haystack extension.

Advantages of Jina Embeddings v2

Handling long documents. The large token window, accommodating up to 8192 tokens, allows you to break the embeddings into larger chunks. It's more computationally and memory-efficient to use a few larger vectors than a lot of small ones, so this allows Jina v2 to process large documents efficiently.
Improved semantic understanding. Larger text chunks also contain more context within each chunk, which can help LLMs better understand your documents. Improved understanding means better long document retrieval, semantic textual similarity, text reranking, recommendation, RAG and LLM-based generative search.
Short vector length: Jina Embeddings v2 emits embedding vectors of length 768 (base model) or 512 (small model), which are both significantly less than that of the only other embedding model that supports 8k tokens input length, while not compromising on the quality of retrieval, similarity, reranking or other downstream tasks. A shorter vector length implies cost-savings for the vector database, which typically price based on stored vector dimensions.
Fully open source 💙 There are both small and large embedding models available, depending on your computing resources and requirements. To run the embedding models yourself, check out this documentation on HuggingFace. Alternately, you can use Jina's fully managed embedding service to handle that for you, which we'll be doing for this demo.

Getting started using Jina Embeddings v2 with Haystack

To use the integration you'll need a free Jina api key - get one here.

You can use Jina Embedding models with two Haystack components: JinaTextEmbedder and JinaDocumentEmbedder.

To create semantic embeddings for documents, use JinaDocumentEmbedder in your indexing pipeline. For generating embeddings for queries, use JinaTextEmbedder.

In the following code we'll demonstrate how to use both components. You can also see the Haystack docs for some minimum viable code examples.

Summarizing legal text with a Haystack RAG pipeline

I'm not a lawyer, and neither are large language models. But LLMs are good at analyzing long, complex documents. So let's try using the Jina v2 embedding models for some legal summarization.

In October 2023, I narrowly escaped jury duty. I had slight FOMO since the case sounded interesting (Google v. Sonos). Let's see how it turned out.

To follow along with this demo, in addition to a Jina api key you'll also need a Hugging Face access token, since we'll use the Mixtral 8x7b LLM for question answering.

First, let's install all the packages we'll need.

pip install jina-haystack chroma-haystack pypdf

Then let's input our credentials. Or you can set them as environment variables instead if you're feeling fancy.

import getpass

jina_api_key  = getpass.getpass("JINA api key:")
hf_token = getpass.getpass("Enter your HuggingFace api token:")

Building the indexing pipeline

Our indexing pipeline will preprocess the legal document, turn it into vectors, and store them. We'll use the Chroma DocumentStore to store the vector embeddings, via the Chroma Document Store Haystack integration.

from chroma_haystack.document_store import ChromaDocumentStore
document_store = ChromaDocumentStore()

At a high level, the LinkContentFetcher pulls this document from its URL. Then we convert it from a PDF into a Document object Haystack can understand.

We preprocess it by removing whitespace and redundant substrings. Then split it into chunks, generate embeddings, and write these embeddings into the ChromaDocumentStore.

from haystack import Pipeline

from haystack.components.fetchers import LinkContentFetcher
from haystack.components.converters import PyPDFToDocument
from haystack.components.writers import DocumentWriter
from haystack.components.preprocessors import DocumentCleaner
from haystack.components.preprocessors import DocumentSplitter
from chroma_haystack.retriever import ChromaEmbeddingRetriever
from haystack.document_stores import DuplicatePolicy

from jina_haystack.document_embedder import JinaDocumentEmbedder
from jina_haystack.text_embedder import JinaTextEmbedder

fetcher = LinkContentFetcher()
converter = PyPDFToDocument()
# remove repeated substrings to get rid of headers/footers
cleaner = DocumentCleaner(remove_repeated_substrings=True)

# Since jina-v2 can handle 8192 tokens, 500 words seems like a safe chunk size
splitter = DocumentSplitter(split_by="word", split_length=500)

# DuplicatePolicy.SKIP is optional but helps avoid errors if you want to re-run the pipeline
writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.SKIP)

retriever = ChromaEmbeddingRetriever(document_store=document_store)

document_embedder = JinaDocumentEmbedder(api_key=jina_api_key, model_name="jina-embeddings-v2-base-en")

indexing_pipeline = Pipeline()
indexing_pipeline.add_component(instance=fetcher, name="fetcher")
indexing_pipeline.add_component(instance=converter, name="converter")
indexing_pipeline.add_component(instance=cleaner, name="cleaner")
indexing_pipeline.add_component(instance=splitter, name="splitter")
indexing_pipeline.add_component(instance=document_embedder, name="embedder")
indexing_pipeline.add_component(instance=writer, name="writer")

indexing_pipeline.connect("fetcher.streams", "converter.sources")
indexing_pipeline.connect("converter.documents", "cleaner.documents")
indexing_pipeline.connect("cleaner.documents", "splitter.documents")
indexing_pipeline.connect("splitter.documents", "embedder.documents")
indexing_pipeline.connect("embedder.documents", "writer.documents")

# This case references Google V Sonos, October 2023
urls = ["https://cases.justia.com/federal/district-courts/california/candce/3:2020cv06754/366520/813/0.pdf"]

indexing_pipeline.run(data={"fetcher": {"urls": urls}})

Building the query pipeline

Now the real fun begins. Let's create a query pipeline so we can actually start asking questions. We write a prompt allowing us to pass our documents to the Mixtral-8x7B LLM. Then we initiatialize the LLM via the HuggingFaceTGIGenerator.

In Haystack 2.0 retrievers are tightly coupled to DocumentStores. If we pass the document store in the retriever we initialized earlier, this pipeline can access those embeddings we generated, and pass them to the LLM.


from haystack.components.generators import HuggingFaceTGIGenerator
from haystack.components.builders.prompt_builder import PromptBuilder

from jina_haystack.text_embedder import JinaTextEmbedder
prompt = """ Answer the question, based on the
content in the documents. If you can't answer based on the documents, say so.

Documents:
{% for doc in documents %}
  {{doc.content}}
{% endfor %}

question: {{question}}
"""

text_embedder = JinaTextEmbedder(api_key=jina_api_key, model_name="jina-embeddings-v2-base-en")
generator = HuggingFaceTGIGenerator("mistralai/Mixtral-8x7B-Instruct-v0.1", token=hf_token)
generator.warm_up()

prompt_builder = PromptBuilder(template=prompt)
query_pipeline = Pipeline()
query_pipeline.add_component("text_embedder",text_embedder)
query_pipeline.add_component(instance=prompt_builder, name="prompt_builder")
query_pipeline.add_component("retriever", retriever)
query_pipeline.add_component("generator", generator)

query_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
query_pipeline.connect("retriever.documents", "prompt_builder.documents")
query_pipeline.connect("prompt_builder.prompt", "generator.prompt")

Time to ask a question!

question = "Summarize what happened in Google v. Sonos"

result = query_pipeline.run(data={"text_embedder":{"text": question},
                                  "retriever": {"top_k": 3},
                                  "prompt_builder":{"question": question},
                                  "generator": {"generation_kwargs": {"max_new_tokens": 350}}})

print(result['generator']['replies'][0])

Answer: Google v. Sonos is a patent infringement case in which Sonos sued Google for infringing on two of its patents related to customizing and saving overlapping groups of smart speakers or other zone players according to a common theme..

Exploring more questions and documents

You can swap the question variable out and then call pipeline.run again:

What role did If This Then That play in Google v. Sonos?
What judge presided over Google v. Sonos?
What should Sonos have done differently?

The indexing pipeline is written so that you can swap in other documents and analyze them. You can try plugging the following URLs (or any PDF written in English) into the indexing pipeline and re-running all the code blocks below it.

Google v. Oracle: https://supreme.justia.com/cases/federal/us/593/18-956/case.pdf
JACK DANIEL’S PROPERTIES, INC. v. VIP PRODUCTS LLC: https://www.supremecourt.gov/opinions/22pdf/22-148_3e04.pdf

Note: if you want to change the prompt template, you'll also need to re-run the code blocks starting where the DocumentStore is defined.

Wrapping it up

Thanks for reading! If you want to stay on top of the latest Haystack developments, you can subscribe to our newsletter or join our Discord community.

To learn more about the technologies used here, check out these blog posts:

Building a Healthcare Chatbot with Mixtral 8x7b, Haystack, and PubMed

Tilde A. Thurium — Tue, 02 Jan 2024 17:53:14 +0000

Unfortunately, countless people around the world have inadequate access to healthcare. I’m lucky to have health insurance and good medical providers taking care of me. However, I still want to educate myself before walking into a doctor’s office.

Technology can empower people to take charge of their health. Large language models can power chatbots where people can ask medical questions.

In this post, I’ll show you how I built a medical chatbot with Haystack 2.0-Beta, and the Mixtral 8x7B model by pulling research papers from PubMed.

You can follow along with this Colab. You’ll need a HuggingFace API key. Sign up for a free account here.

Challenges

Building a medical chatbot presents some challenges.

Lack of data. HIPAA and other privacy regulations make it harder to find public QA datasets to fine-tune a model.
The human impact of providing wrong answers. 😬
Staying up to date. It takes a long time to train a LLM. By the time they are released, their knowledge is already a bit stale. Medical research breakthroughs are happening all the time. I am particularly interested in long COVID, which has both impacted humanity on a massive scale, and is the subject of ongoing research.

Therefore, I decided to use a RAG pipeline to combine PubMed data with a LLM.

The PubMed RAG Pipeline

Retrieval augmented generation, or RAG, is a way of giving a LLM context so it can better answer questions.

You pass the LLM some documents, along with a query, and prompt the LLM to use the documents when answering the question.

PubMed has up to date, trustworthy medical information so it seemed like a solid document source. Plus, there's a PyMed wrapper for the PubMed API that made querying easy peasy. We'll wrap this in a Haystack custom component to format the results as Documents so that Haystack can use them, and add some light error handling.

from pymed import PubMed
from typing import List
from haystack import component
from haystack import Document

pubmed = PubMed(tool="Haystack2.0Prototype", email="tilde.thurium@deepset.ai")

def documentize(article):
  return Document(content=article.abstract, meta={'title': article.title, 'keywords': article.keywords})

@component
class PubMedFetcher():

  @component.output_types(articles=List[Document])
  def run(self, queries: list[str]):
    cleaned_queries = queries[0].strip().split('\n')

    articles = []
    try:
      for query in cleaned_queries:
        response = pubmed.query(query, max_results = 1)
        documents = [documentize(article) for article in response]
        articles.extend(documents)
    except Exception as e:
        print(e)
        print(f"Couldn't fetch articles for queries: {queries}" )
    results = {'articles': articles}
    return results

For the model, I went with Mixtral's 8x7b. Mixtral is a unique kind of model that uses 8 "experts" and an internal "routing" mechanism that routes a token to a specific expert. This also means that during inferencing, not all parameters are used, which allows the model to response remarkably fast. This HuggingFace blog post explains MoE in more detail.

Generating Keywords for PubMed with Mixtral/LLMs

First, I tried an approach where I passed a plain query to PubMed. e.g. "What are the most current treatments for long COVID?" Unfortunately, that didn't work too well. The articles returned weren't very relevant. Which makes sense, because PubMed isn't optimized for natural language search. It is optimized for keywords, though. And you know what's great at generating keywords? LLMs!

So now our flow is as follows:

Our user inputs a question, such as, "What are the most current treatments for long COVID?"
We prompt the LLM to turn the question into keywords
Search PubMed and return top_k articles based on those keywords
Pass those articles to the LLM and ask them to reference it when formulating an answer.

![A flowchart showing the architecture of the Healthcare Chatbot. The boxes are Query, Keyword Prompt, LLM, Keywords, PubMedFetcher, Articles, Query Prompt, LLM, Ansswer.](HealthcareChatbotArchitecture.png](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xmmdud2pnkfv444k50pw.png)

First, initialize the LLMs and warm them up.

from haystack.components.generators import HuggingFaceTGIGenerator

keyword_llm = HuggingFaceTGIGenerator("mistralai/Mixtral-8x7B-Instruct-v0.1", token=huggingface_token)
keyword_llm.warm_up()

llm = HuggingFaceTGIGenerator("mistralai/Mixtral-8x7B-Instruct-v0.1", token=huggingface_token)
llm.warm_up()

Next, we create our prompts and our pipeline and hook everything up.

from haystack import Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder

keyword_prompt_template = """
Your task is to convert the follwing question into 3 keywords that can be used to find relevant medical research papers on PubMed.
Here is an examples:
question: "What are the latest treatments for major depressive disorder?"
keywords:
Antidepressive Agents
Depressive Disorder, Major
Treatment-Resistant depression
---
question: {{ question }}
keywords:
"""

prompt_template = """
Answer the question truthfully based on the given documents.
If the documents don't contain an answer, use your existing knowledge base.

q: {{ question }}
Articles:
{% for article in articles %}
  {{article.content}}
  keywords: {{article.meta['keywords']}}
  title: {{article.meta['title']}}
{% endfor %}

"""
keyword_prompt_builder = PromptBuilder(template=keyword_prompt_template)
prompt_builder = PromptBuilder(template=prompt_template)
fetcher = PubMedFetcher()

pipe = Pipeline()

pipe.add_component("keyword_prompt_builder", keyword_prompt_builder)
pipe.add_component("keyword_llm", keyword_llm)
pipe.add_component("pubmed_fetcher", fetcher)
pipe.add_component("prompt_builder", prompt_builder)
pipe.add_component("llm", llm)

pipe.connect("keyword_prompt_builder.prompt", "keyword_llm.prompt")
pipe.connect("keyword_llm.replies", "pubmed_fetcher.queries")

pipe.connect("pubmed_fetcher.articles", "prompt_builder.articles")
pipe.connect("prompt_builder.prompt", "llm.prompt")

Try it for yourself and see!

question="What are the most current treatments for long COVID?"
pipe.run(data={"keyword_prompt_builder":{"question":question},
               "prompt_builder":{"question": question},
               "llm":{"generation_kwargs": {"max_new_tokens": 500}}})

What are the most current treatments for long COVID?
  The COVID-19 pandemic has led to a significant increase in the number of patients with post-acute COVID-19 syndrome (PACS), also known as long COVID. PACS is a complex, multisystem disorder that can affect various organs and systems, including the respiratory, cardiovascular, neurological, and gastrointestinal systems. The pathophysiology of PACS is not yet fully understood, but it is believed to be related to immune dysregulation, persistent inflammation, and microvascular injury.
The management of PACS is challenging due to its heterogeneous presentation and the lack of evidence-based treatments. Current treatment approaches are mainly supportive and aim to alleviate symptoms and improve quality of life. These include:
- Pulmonary rehabilitation for respiratory symptoms
- Cardiac rehabilitation for cardiovascular symptoms
- Cognitive-behavioral therapy for neurological symptoms
- Dietary modifications and medications for gastrointestinal symptoms
- Vaccination to prevent reinfection and further complications
- Symptomatic treatment with medications such as nonsteroidal anti-inflammatory drugs (NSAIDs), corticosteroids, and antihistamines
- Experimental treatments such as antiviral therapy, immunomodulatory therapy, and cell-based therapy

Potential issues and workarounds

PubMed API wasn’t built for high scalability, so this approach wouldn’t be great for a high traffic production system. In that case, you could consider pulling articles into a Haystack DocumentStore that is backed by persistent storage

Alternately, you could experiment with models that has been trained on a medical dataset, such as Gradient's.

Wrapping it up

Today you learned how to use Mixtral 8x7B and Haystack RAG pipelines to build a medical chatbot. Thanks for reading! If you want to learn more about Haystack 2.0 or RAG Pipelines, these posts might be of interest:

Fighting Imposter Syndrome With IoT, with Tilde Thurium

Tilde A. Thurium — Thu, 23 Jul 2020 11:56:23 +0000

Tilde Thurium is an artist, engiqueer, and activist. In previous lives, they have done stints as a florist, a security guard, and a Human Resources wench. In their spare time, they illustrate data structures and algorithms with acrylic paint.

My talk is a live demo of how I fought imposter syndrome by building a physical button to send daily affirmations via SMS! The demo is also interactive, so I hope you'll participate.

For more details, check out my post on Dev about this build

This talk will be presented as part of CodeLand:Distributed on July 23. After the talk is streamed as part of the conference, it will be added to this post as a recorded video.

Sending a SMS from Gatsby with serverless functions and React

Tilde A. Thurium — Mon, 06 Jul 2020 22:40:18 +0000

Today I’ll teach you to send a SMS message from a Gatsby website using Twilio Serverless Functions and React. But first, what is Gatsby and why should you care?

Gatsby 101

If you spend time in JavaScript land, you might have heard of the JAMstack -- JavaScript, APIs, and Markup.

Traditional web apps dynamically generate HTML from templates when the server receives a request. JAMstack websites use static site generators to turn templates into HTML when the site is deployed, instead of when a request comes in.

Since plain ol’ HTML can be much faster to serve, JAMstack can give you a huge performance boost. Especially if you’re using a content delivery network. Although, there are limits to the amount of UI complexity static sites can support.

Gatsby bridges the gap between JAMstack static sites and traditional web apps. You write React components that compile to HTML plus a little bit of JavaScript to support user interactivity. Gatsby is essentially a hybrid where you have the best of both worlds.

For more detail, check out this thorough blog post about how Gatsby and other React apps differ.

Gatsby is also fully open source and run by a foundation. And it’s got a whole ecosystem with plugins, themes, and starters that empower you to build on the work of others.

Your first Gatsby site

Before you do anything else you’ll need to set up your Gatsby development environment.

A starter is an example of an entire Gatsby site you can clone and build on top of. From the terminal, run the following command to create a new project using the default starter:

gatsby new my-default-starter https://github.com/gatsbyjs/gatsby-starter-default

Open the my-default-starter folder in your favorite editor. Run the following command to get started developing:

  cd my-default-starter
  gatsby develop

Amongst the output you should see something like:

You can now view gatsby-starter-default in the browser.

  http://localhost:8000/

Go to that URL in a browser and see the Gatsby default starter running on your local host. 🎉

Add an SMS form to Gatsby

Now we’re going to modify the default starter by adding a form. Gatsby project structure isn’t too important for our purposes today, but if you want to learn more check out the Gatsby docs.

In the src/components folder, create a new file called SMSForm.js. Add the following code to it:

import React from "react"

class SMSForm extends React.Component {
 constructor(props) {
   super(props)
   this.state = {
     buttonDisabled: true,
     message: { to: "", body: "" },
     submitting: false,
     error: null,
   }
 }

 onChange = event => {
   const name = event.target.getAttribute("name")
   this.setState({
     message: { ...this.state.message, [name]: event.target.value },
   })
 }
 render() {
   return (
     <>
       <div>{this.state.error}</div>
       <form
         style={{
           display: `flex`,
           flexDirection: `column`,
           maxWidth: `500px`,
         }}
         method="post"
       >
         <label htmlFor="to">To:</label>
         <input
           type="tel"
           name="to"
           id="to"
           value={this.state.message.to}
           onChange={this.onChange}
         ></input>
         <label htmlFor="body">Body:</label>
         <textarea
           name="body"
           id="body"
           value={this.state.message.body}
           onChange={this.onChange}
           maxLength="160"
         />
         <button
           style={{
             marginTop: `7px`,
           }}
           type="submit"
           disabled={this.state.submitting}
         >
           Send message
         </button>
       </form>
     </>
   )
 }
}

export default SMSForm

The form asks for the recipient’s phone number, as well as the text you want to send them. The SMSForm component manages this data as React state so that it’s easy to submit and clear the data. It also has some state to disable the button when the form is being submitted, and show error text if any exists.

If you want more detailed step-by-step instructions on building out a SMS form in React, check out this blog post.

Before we can see our work, we’ll need to add SMSForm into our component tree. Open up pages/index.js and replace it with the following:

import React from "react"
import { Link } from "gatsby"

import Layout from "../components/layout"
import Image from "../components/image"
import SEO from "../components/seo"
import SMSForm from "../components/SMSForm"

const IndexPage = () => (
 <Layout>
   <SEO title="Home" />
   <h1>Hi people</h1>
   <p>Welcome to your new Gatsby site.</p>
   <p>Now go build something great.</p>
   <SMSForm></SMSForm>
   <div style={{ maxWidth: `300px`, marginBottom: `1.45rem` }}>
     <Image />
   </div>
   <Link to="/page-2/">Go to page 2</Link> <br />
   <Link to="/using-typescript/">Go to "Using TypeScript"</Link>
 </Layout>
)

export default IndexPage

Save index.js in your editor. As soon as you do so, the browser reloads automatically and our form shows up. Neat!

Add a serverless function

Our form doesn’t do anything yet, so let’s fix that. To integrate Twilio into the site, we’ll need some sort of back end. Storing Twilio credentials on the front end is a “DON’T” as that exposes them to potential attackers. Lucky for us, the "A" in JAMstack stands for APIs which includes serverless functions. We don’t need to spin up an entire server just to send a message.

If you don’t have a Twilio account now’s the time to sign up for one. After you’ve done that buy and configure a Twilio phone number with SMS capabilities.

Go to the Twilio Functions dashboard. Make sure the checkbox for enabling your ACCOUNT_SID and AUTH_TOKEN environment variables is checked. Click the “+” button to create a new function from a blank template. Your function will need a name and a path. Let’s go with “Send SMS” and “send-sms” respectively.

Uncheck the box that says “Check for valid Twilio signature” since we’ll be making a request from a non-Twilio domain. Copy the following code into the function body. Replace the from value with your Twilio number:

exports.handler = async function (context, event, callback) {
 const client = context.getTwilioClient()
 const response = new Twilio.Response()
 response.setHeaders({
   "Access-Control-Allow-Origin": "http://localhost:8000",
   "Content-Type": "application/json",
 })

 try {
   await client.messages.create({
     to: event.to,
     from: "", // replace this with your Twilio number in e.164 format
     body: event.body,
   })
   response.setBody({})
   response.setStatusCode(200)
 } catch (error) {
   response.setBody({ error })
   response.setStatusCode(500)
 }

 callback(null, response)
}

At a high level this code is passing along the message body and the recipient number along to our Twilio client which then creates the message. Since we are making a request from localhost to a different domain, we need to set CORS headers in our function response or the request will fail. The Twilio response object gives us granular control over headers and status codes. Using a response object also enables us to pass any errors through to the client so that the user knows what’s going on when things fail.

If you were going to deploy your Gatsby site to staging or production, you’d need to refactor this code a little. A CORS header can only contain one domain. You’d need some server-side logic to dynamically construct the header based on the list of domains you want to allow.

Hit the “Save” button so that your function deploys itself. Copy the path of your function because we’ll need it in a second.

Going back to your editor, let’s modify the SMSForm to actually make a request to the serverless function. Copy the following code into SMSForm.js and replace the functionURL with your own.

import React from "react"

const functionURL = "" // replace with your function URL

class SMSForm extends React.Component {
 constructor(props) {
   super(props)
   this.state = {
     buttonDisabled: true,
     message: { to: "", body: "" },
     submitting: false,
     error: null,
   }
 }

 onClick = async event => {
   event.preventDefault()
   this.setState({ submitting: true })
   const { to, body } = this.state.message
   const response = await fetch(functionURL, {
     method: "post",
     headers: {
       "Content-type": "application/x-www-form-urlencoded; charset=UTF-8",
     },
     body: new URLSearchParams({ to, body }).toString(),
   })
   if (response.status === 200) {
     this.setState({
       error: null,
       submitting: false,
       message: {
         to: "",
         body: "",
       },
     })
   } else {
     const json = await response.json()
     this.setState({
       error: json.error,
       submitting: false,
     })
   }
 }

 onChange = event => {
   const name = event.target.getAttribute("name")
   this.setState({
     message: { ...this.state.message, [name]: event.target.value },
   })
 }
 render() {
   return (
     <>
       <div>{this.state.error}</div>
       <form
         style={{
           display: `flex`,
           flexDirection: `column`,
           maxWidth: `500px`,
         }}
         method="post"
         action={functionURL}
       >
         <label htmlFor="to">To:</label>
         <input
           type="tel"
           name="to"
           id="to"
           value={this.state.message.to}
           onChange={this.onChange}
         ></input>
         <label htmlFor="body">Body:</label>
         <textarea
           name="body"
           id="body"
           value={this.state.message.body}
           onChange={this.onChange}
           maxLength="160"
         />
         <button
           style={{
             marginTop: `7px`,
           }}
           type="submit"
           disabled={this.state.submitting}
           onClick={this.onClick}
         >
           Send message
         </button>
       </form>
     </>
   )
 }
}

export default SMSForm

We added a click handler function to handle the form submission. Our click handler makes a fetch request to the serverless function. If all is well we reset the form state to blank and the message is sent. If there’s an error, we pop that into the component’s state so we can show the user what went wrong.

Try the form out. Send yourself any message you’d like, but might I suggest “high five”? You’ve earned it.

Conclusion: How to send a SMS from Gatsby

Today you’ve learned a little about Gatsby and how it fits into the JAMStack world, as well as how to integrate Gatsby and Twilio with serverless functions. But there’s always more to learn. Gatsby has fantastic documentation, so if you want to dive in deeper I’d encourage you to start there.

If you have built something cool with Gatsby, I’d love to hear about it. Let me know on Twitter or in the comments below.

Writing to Airtable from a Twilio serverless function

Tilde A. Thurium — Tue, 12 May 2020 21:25:44 +0000

Airtable is an awesome product. It’s like a cross between a spreadsheet and a database, but with a lot more flexibility for creating dynamic views of your data. In this post you’ll learn how to write to Airtable from a Twilio application. The advantages of doing so are as follows:

Rapid prototyping. If you need to persistently store data, it’s easier to create an Airtable base than to set up a proper database.
Maintenance flexibility. Folks who don’t know how to code can easily maintain and extend the data.
Seamless authentication. Sure, you could use Google Sheets as a lightweight database, but authenticating with Google Sheets API can be tricky.

Today we’ll be building a Net Promoter Score (NPS) app that writes data from SMS messages to Airtable. NPS is a calculated value summarizing how a group of people feel about something -- a brand, an event, whatever. That said, this code is just a starting point. Feel free to customize it for whatever your use case might be.

Prerequisites

A Twilio account -- sign up for a free one here and receive an extra $10 when you upgrade your account
A free Airtable account
A Twilio phone number with SMS capabilities

Airtable 101

In order to use Airtable, you need to be familiar with a few key concepts. If you’re already an Airtable whiz, feel free to skip to the “Writing to Airtable with a serverless function” section.

Bases. According to Airtable documentation, “A base is a database that contains all of the information you need for a specific project.”
Bases are made up of one or more tables. If we’re going with the spreadsheet metaphor, tables are like different tabs.
Records are units of data, analogous to a row on a spreadsheet.
Information in records is stored in fields, which are kind of like a column on a spreadsheet.
Workspaces are folders where you can organize your bases so that other folks can collaborate with you.

To create a new base you can:

Choose one of Airtable’s many official templates
Choose a template created by the Airtable community
Start from scratch

I’ve created a base called “Net Promoter Score” that we’ll be working with today. You can view it here and create your own copy with the “Copy base” button on the right-hand side.

This base contains an “Input” table that has 4 fields:

Number: a unique, automatically incremented field type. The first field in a base is the primary field and must be unique. It’s kind of like a relational database’s primary key.
Score: a number field, representing how good (or bad!) the survey responders feel.
Reason: a long text field allowing the survey responders to provide more context on why they feel that way.
Promoter or Detractor: a formula field performing an intermediate calculation that helps us get to our final NPS score.

A rollup calculation at the bottom of this field gives us our final NPS score.

Writing to Airtable with a serverless function

For this project we'll use a Twilio Function for writing data to the Airtable base. Open the Functions configuration dashboard. Generate an Airtable API key and add it as an environment variable named AIRTABLE_API_KEY.

Be careful not to commit your Airtable API key to code that’s going up on GitHub, or share it with anybody. If you do they can gain full access to your Airtable account.

Go to the Airtable API landing page. You’ll see links to all your bases. Click through on the link to the “Net Promoter Score” base.

On this page, you’ll see some (nifty!) auto-generated API documentation. We’ll need the unique ID of the Net Promoter Score base, so copy that to your clipboard.

Go back to the Twilio functions dashboard. Add the Airtable base ID as an environment variable called AIRTABLE_BASE_ID.

While you’re at it, add the Airtable Node.js SDK to the Dependencies section of the Functions configuration dashboard. Here we’re using version ^0.8.1.

Let’s write a Function that, given a string and a number, writes a new row to our NPS base. Using the “Blank” template, create a new Function called writeNPS. Give it a path, /write-nps. Copy the following code into it:

const airtable = require("airtable");
const twilio = require("twilio");

exports.handler = function (context, event, callback) {
 const base = new airtable({
   apiKey: context.AIRTABLE_API_KEY,
 }).base(context.AIRTABLE_BASE_ID);
 base("Input").create(
   [
     {
       fields: {
         Reason: event.reason,
         Score: parseInt(event.numericalScore),
       },
     },
   ],
   function (error, records) {
     if (error) {
       console.error(error);
       callback(error);
       return;
     } else {
       callback(null, "Success!");
     }
   }
 );
};

Uncheck the box that says “Check for valid Twilio signature” so we can test this function by running local commands. Copy your function URL into the code below and run it from from the command line:

curl --request POST 'https://YOUR-FUNCTION-URL.twil.io/write-nps?numericalScore=7&reason=You%20had%20impeccable%20can%C3%A1pes.' \
--header 'Content-Type: application/x-www-form-urlencoded'
Success!

What is even happening in this function? Let’s break it down.

First, we instantiate the Airtable base.
Then we call the create method, to create a new row. Although we’re only creating one row here, this method accepts a list of objects if you want to bulk create.
The second argument to create is a function allowing us to do some error handling and call the callback to let Twilio know our function is done executing.

Warning: as I found out the hard way, Airtable creates empty rows for failed requests. 😭

me: makes an error during Airtable API request
Airtable: HEY EVERYONE LOOK AT THIS FAILED REQUEST

Type issues are another gotcha. In the previous code sample we needed to convert strings to numbers for the Score field. If not, the request will fail because the Score field uses the “Number” data type. Airtable offers automatic type coercion that you can enable if you want to live dangerously. Then again, we’re using JavaScript here which already has a bunch of weird type coercion edge cases so YOLO.

To enable type conversion, pass the typecast parameter in to the create method like so:

 base("Input").create(
   [
     {
       fields: {
         Reason: event.reason,
         Score: event.numericalScore,
       },
     },
   ],
   { typecast: true },
   function (error, records) {
   ...

To test this you can run the same cURL command you ran previously since the inputs to the function haven’t changed.

Airtable also has methods for updating and deleting records, though they aren’t super applicable for our use case. Check out the Airtable API documentation for details.

Adding a Twilio Studio flow for Net Promoter Score

Twilio Studio is the fastest way to get multi-step messaging flows up and running. To save time, you can copy my flow by importing the following JSON into Studio. Before importing you’ll need to replace the example.com URL with the URL of the function you just wrote.

{
  "description": "NPS Survey",
  "states": [
    {
      "name": "Trigger",
      "type": "trigger",
      "transitions": [
        {
          "next": "NPS-Numerical-Score",
          "event": "incomingMessage"
        },
        {
          "event": "incomingCall"
        },
        {
          "event": "incomingRequest"
        }
      ],
      "properties": {
        "offset": {
          "x": 0,
          "y": 0
        }
      }
    },
    {
      "name": "NPS-Numerical-Score",
      "type": "send-and-wait-for-reply",
      "transitions": [
        {
          "next": "NPS-Text-Reason",
          "event": "incomingMessage"
        },
        {
          "event": "timeout"
        },
        {
          "event": "deliveryFailure"
        }
      ],
      "properties": {
        "offset": {
          "x": -140,
          "y": 250
        },
        "service": "{{trigger.message.InstanceSid}}",
        "channel": "{{trigger.message.ChannelSid}}",
        "from": "{{flow.channel.address}}",
        "body": "On a scale of 1-10, how likely are you to recommend this event to a friend?",
        "timeout": 3600
      }
    },
    {
      "name": "send-thanks",
      "type": "send-message",
      "transitions": [
        {
          "event": "sent"
        },
        {
          "event": "failed"
        }
      ],
      "properties": {
        "offset": {
          "x": -110,
          "y": 930
        },
        "service": "{{trigger.message.InstanceSid}}",
        "channel": "{{trigger.message.ChannelSid}}",
        "from": "{{flow.channel.address}}",
        "to": "{{contact.channel.address}}",
        "body": "Thank you so much for the feedback, and most importantly for participating in the event!"
      }
    },
    {
      "name": "NPS-Text-Reason",
      "type": "send-and-wait-for-reply",
      "transitions": [
        {
          "next": "write-data",
          "event": "incomingMessage"
        },
        {
          "event": "timeout"
        },
        {
          "event": "deliveryFailure"
        }
      ],
      "properties": {
        "offset": {
          "x": -130,
          "y": 510
        },
        "service": "{{trigger.message.InstanceSid}}",
        "channel": "{{trigger.message.ChannelSid}}",
        "from": "{{flow.channel.address}}",
        "body": "What's your primary reason for giving that score?",
        "timeout": 3600
      }
    },
    {
      "name": "write-data",
      "type": "make-http-request",
      "transitions": [
        {
          "next": "send-thanks",
          "event": "success"
        },
        {
          "event": "failed"
        }
      ],
      "properties": {
        "offset": {
          "x": -120,
          "y": 710
        },
        "method": "POST",
        "content_type": "application/x-www-form-urlencoded;charset=utf-8",
        "parameters": [
          {
            "value": "{{widgets.NPS-Numerical-Score.inbound.Body}}",
            "key": "numericalScore"
          },
          {
            "value": "{{widgets.NPS-Text-Reason.inbound.Body}}",
            "key": "reason"
          }
        ],
        "url": "http://example.com"
      }
    }
  ],
  "initial_state": "Trigger",
  "flags": {
    "allow_concurrent_calls": true
  }
}

After you’ve imported the Studio flow, hook it up to your Twilio phone number.

Conclusion: writing to an Airtable base from your Twilio app

In this post, you’ve learned to:

Write data to an Airtable base with a serverless function
Import a Twilio Studio flow that performs a NPS survey

If you want to learn more about Airtable, check out this post about how to read Airtable data from a Twilio Function. In the meantime, hit me up on Twitter or over email (tthurium [at] twilio [dot] com) if you have any questions.

Using Airtable as a database for your Twilio app

Tilde A. Thurium — Thu, 30 Apr 2020 18:06:53 +0000

"Air Hockey" photo by LadyDucayne is licensed under CC BY 2.0.

Airtable is an awesome product. It’s like a cross between a spreadsheet and a database, but with a lot more flexibility for creating dynamic views of your data. In this post you’ll learn to read Airtable data from a Twilio serverless application. The advantages of doing so are as follows:

Rapid prototyping. If you need to persistently store data, it’s easier to create an Airtable base than to set up a proper database.
Maintenance flexibility. Folks who don’t know how to code can easily maintain and extend the data.
Easy authentication. Sure, you could use Google Sheets as a lightweight database, but authenticating with Google Sheets API can be tricky.

Today we’ll be building an app that returns facts about animals, but you can customize this code to fit your use case.

Prerequisites

A Twilio account -- sign up for a free one here and receive an extra $10 when you upgrade your account
A free Airtable account
A Twilio phone number with SMS capabilities

Airtable 101

In order to use Airtable, you need to be familiar with a few key concepts. If you’re already an Airtable whiz, feel free to skip to the “Reading From Airtable with a serverless function” section.

Bases. According to Airtable documentation, “A base is a database that contains all of the information you need for a specific project.”
Bases are made up of one or more tables, which are essentially like different sheets or tabs of a spreadsheet.
Records are units of data, analogous to a row on a spreadsheet.
Information in records is stored in fields, which are kind of like a column on a spreadsheet.
Workspaces are folders where you can organize your bases so that other folks can collaborate with you.

To create a new base you can:

Choose one of Airtable’s many official templates
Choose a template created by the Airtable community
Start from scratch

I’ve created a small base called “Cute Animals” that we’ll be working with today. You can view it [here])(https://airtable.com/shr5u6b5xR9mBcLYZ) and create your own copy with the “Copy base” button on the right-hand side.

This base contains a “Cute Animals” table that has 3 fields:

Name, a single line text field
Genus, a link to another record (in the Genus table)
Fact, a long text field

It also contains a “Genus” table that has 2 fields:

Name, a single line text field
Cute Animals, a link to another record (in the “Cute Animals” table)

While you’re in Airtable, let’s get some credentials. Generate an Airtable API key and save it somewhere -- you’ll need it in a minute.

Be careful not to commit your Airtable API key to any code that's going up on GitHub, or share it with anybody. If you do they can gain full access to your Airtable account.

Each base has a unique ID number. Make a note of your Airtable base ID which can be found in the (nifty!) auto-generated API documentation for that specific base.

Reading Airtable data from a serverless function

We'll use a Twilio Function to receive an incoming SMS message and fetch data from our Airtable base. Open the Functions configuration dashboard. Add your Airtable API key and base IDs as environment variables, AIRTABLE_API_KEY And AIRTABLE_BASE_ID respectively.

While you’re at it, add the Airtable Node.js SDK to the Dependencies section of the Functions configuration dashboard. Here we’re using version ^0.8.1 (that is, 0.8.1 or the latest minor patch Hit “Save” to save all your configuration changes.

Let’s write a Function that, given an animal name, returns the animal fact. This will show you how to filter airtable records by field for a simple text search. Using the blank template, create a new Function called getAnimalFact. Give it a path, /get-animal-fact. Copy the following code into it:

const airtable = require("airtable");
const twilio = require("twilio");

exports.handler = function (context, event, callback) {
 const base = new airtable({
   apiKey: context.AIRTABLE_API_KEY,
 }).base(context.AIRTABLE_BASE_ID);
 const twiml = new Twilio.twiml.MessagingResponse();
 const animalName = event.Body.toLowerCase();

 return base("Cute Animals")
   .select()
   .all()
   .then((records) => {
     records.forEach((record) => {
       if (record.get("Name") === animalName) {
         twiml.message(record.get("Fact"));
         callback(null, twiml);
       }
     });
     twiml.message(
       `Sorry, we couldn't find any facts about the ${animalName}.`
     );
     callback(null, twiml);
   })
   .catch((error) => {
     callback(error);
   });
};

What is even happening here? Let’s break it down.

First, we instantiate the Airtable base. The select method allows you to select your view, which returns the records in the order listed in that view. Called with no args, records are returned in random order.
The all method is asynchronous and returns every record in the view. Which is okay if you have a small number of records, but for larger bases you may want to paginate using the eachPage function. See the Airtable auto-generated API docs for an example.
Then we iterate through the records until we find a matching one, grab data from the field we want, and wrap it in some good old-fashioned TwiML so the Twilio API can send it as a text message.
This code returns the Fact field of the first matching record.

After adding this code, save your Function and wait for it to deploy itself. On the phone numbers dashboard, configure your Twilio number to call this Function when a new message comes in.

Test it out by texting “Cat” to your Twilio number. You should receive the following response:

The collective noun for a group of adult cats is a clowder. Not to be confused with chowder.

Testing error paths is important too. If we try the same with zebra, we get the following output:

Sorry, we couldn't find any facts about the zebra.

Fetching linked record data from Airtable

One real power of Airtable is that you can have many different field types, including:

URLs
Dates
Phone numbers
Email addresses
Links to other records

See a full list of Airtable field types at this link.

Links to other records are powerful, and give you lightweight relational database functionality. Let’s add the Genus field, which is a link to another record, to our SMS response.

Fetching the linked data requires an additional API call. In the code below, we’ll use the find method to fetch one record with a specific ID. Replace the code in your Function with the following:

const airtable = require("airtable");
const twilio = require("twilio");

exports.handler = function (context, event, callback) {
 const base = new airtable({
   apiKey: context.AIRTABLE_API_KEY,
 }).base(context.AIRTABLE_BASE_ID);

 const animalName = event.Body.toLowerCase();
 let fact = null;
 return base("Cute Animals")
   .select()
   .all()
   .then((records) => {
     let genusId = null;
     const twiml = new Twilio.twiml.MessagingResponse();
     const record = records.find(
       (record) => record.get("Name") === animalName
     );
     if (record) {
       fact = record.get("Fact");
       genusId = record.get("Genus");
     } else {
       twiml.message(
         `Sorry, we couldn't find any facts about the ${animalName}.`
       );
       callback(null, twiml);
     }
     base("Genus")
       .find(genusId)
       .then((record) => {
         twiml.message(
           `${fact} Also, the genus of a ${animalName} is ${record.get(
             "Name"
           )}.`
         );
         callback(null, twiml);
       });
   })
   .catch((error) => {
     console.log(error);
     callback(error);
   });
};

Save your Function again.

Text dog to the number and witness the following response:

Hot dogs (the food) were named after dachshunds, also known as the lowrider of dogs. Also, the genus of a dog is Canis.

Conclusion

In this post, you’ve learned to:

Fetch plain text data and linked records using the Airtable Node.js SDK
Create a Twilio app backed backed by a serverless Function and an Airtable base

If you're interested in learning more, the next post in this series explains how to write to Airtable from a SMS message.

I’ve heard about so many awesome Airtable projects recently, such as this mutual aid tool to help community groups keep people fed during the covid crisis. If you’re building something cool I’d love to hear from you. Hit me up on Twitter or send me an email: tthurium [at] twilio [dot] com.

Forwarding SMS and voice calls to an alternate phone number

Tilde A. Thurium — Mon, 13 Apr 2020 20:45:03 +0000

Balancing privacy and convenience can be tricky. Today I’ll show you how to forward messages and phone calls with Twilio so that you can give out a phone number where people can reach you, while keeping your real phone number a secret.

There are lots of reasons you might want to hide your real phone number. For example:

Transacting with internet strangers such as buying/selling on Craigslist
Giving delivery folks a number to reach you
Putting a phone number on your business card

Prerequisites to create a forwarding number

A Twilio account - sign up for a free one here
A Twilio phone number with SMS and voice capabilities
A phone number you want to forward calls and messages to. For the rest of this post, we’ll call it your cell phone number to simplify things but it can be any number with SMS and voice capabilities.
A friend with a SMS-enabled phone number to help you test things out

Forwarding phone calls with Twilio Studio

Twilio Studio is a visual application builder that allows you to write conditional logic for handling messaging flows without writing any code.

Head to the Studio Dashboard. Click the “+” button to create a new Studio Flow starting from scratch. Let’s call it “message forwarding.”

From the Widget Library on the right-hand side, drag a “Connect Call To” widget on to the canvas. Connect it to the Incoming Call trigger.

Configure the widget to connect the call to a single number and type your cell phone number in the box.

Save the widget configuration, and then click Publish at the top.

Go to the Phone Numbers dashboard. Under “Voice & Fax”, configure your Twilio phone number to use the message forwarding Studio Flow you’ve just created.

Grab a friend. Ask them to call your Twilio phone number to test things out. ☎️ 🎉

One-way SMS forwarding with Twilio Studio

There are a few ways of doing one-way SMS forwarding with Twilio. Since we’ve already got a Studio Flow going, let’s build on top of that.

Drag a Send Message widget onto the canvas. Connect it with the Incoming Message trigger.

Configure the widget so that it sends a message to your cell phone number, from your Twilio phone number. The message body should be:

From: {{trigger.message.Body}} : {{widgets.send_message_1.inbound.Body}}

Don’t forget to publish the changes to your Flow. Ask your friend to help you test by sending a text message to your Twilio number.

Two-way SMS forwarding with Twilio Functions

Let’s say you want to be able to reply to incoming messages from your cell phone. Using Twilio Functions, we’ll write some code to accomplish that.

In order to run this Function, you need 3 pieces of information:

Your cell phone number
The third-party phone number you want to exchange messages with
The Twilio phone number serving as the gateway in the middle

We’ll reconfigure the same Twilio number we were using with Studio earlier to call the Twilio Function whenever a new SMS comes in. Inside the Function, there’s some logic to determine which direction to forward the information.

How do you get the third-party phone number? You can leave the Studio Flow we created earlier hooked up. When a message comes in you want to reply to, copy the phone number out of the message body and drop it into the code below.

On the Functions dashboard, create a new Function called forward SMS. Copy the following code into it:

exports.handler = function (context, event, callback) {
    const yourPhoneNumber = ''; // replace this
    const thirdPartyPhoneNumber = ''; // replace this
    const twilioPhoneNumber = event.To;

    let twiml = new Twilio.twiml.MessagingResponse();
    if (event.From === yourPhoneNumber) {
      twiml.message(event.Body, {
        to: thirdPartyPhoneNumber,
        from: twilioPhoneNumber
      });
    } else {
      twiml.message(`${event.From}: ${event.Body}`, {
        to: yourPhoneNumber,
        from: twilioPhoneNumber
      });
    }
    callback(null, twiml);
  }

Save your Function -- it’ll deploy automatically. Configure your Twilio phone number so that this Function is called when an incoming message arrives.

Ask your friend to send you a SMS. Send them one back, and verify that they received it. Offer to buy them a beverage of their choice to say thanks for the help. ☕

One drawback of this approach is that you’re limited to one conversation at a time. Since the 3rd party phone number is hard coded, it needs to be changed each time you want to converse with a different person. If you’re a high roller who needs to juggle multiple simultaneous conversations with strangers, you could add some conditional logic to specify the number you want to send a message to.

Wrapping it up

In this blog post you’ve learned a few ways of forwarding messages using Twilio Studio and Functions. Go forth and distribute your phone number to the world, more safely.

If you have any questions or issues, feel free to send me a SMS at +1 970-238-3818. You can also reach me on Twitter at @annthurium.