cd..→blog

Unifying AdonisJS, Azure Functions, & Perplexity AI on DigitalOcean

const published = "Jan 10, 2026, 10:21 PM";const readTime = 4 min;
adonisjsazure functionsperplexity apidigitaloceantypescript
Integrate AdonisJS, Azure Functions for Perplexity AI, and DigitalOcean. Build scalable TypeScript apps with serverless AI capabilities.

Unifying AdonisJS, Azure Functions, & Perplexity AI on DigitalOcean

Modern web development in 2026 thrives on robust backends, scalable serverless components, intelligent AI, and cost-effective deployment. This article demonstrates a powerful full-stack architecture integrating AdonisJS, Azure Functions, Perplexity AI, and DigitalOcean into a single, cohesive TypeScript application, offering a blueprint for high-performance and maintainable solutions.

The Architecture at a Glance

Our proposed architecture positions AdonisJS as the primary API gateway, handling user requests and core business logic. Azure Functions provide a serverless execution environment, perfectly suited for offloading AI-intensive tasks to the Perplexity API, ensuring independent scalability and efficient resource usage. DigitalOcean serves as the reliable and straightforward hosting platform for our AdonisJS application, providing both performance and ease of management.

  • AdonisJS: A robust, full-stack framework for building secure and maintainable API endpoints and managing application data with TypeScript.
  • Azure Functions: A serverless compute service enabling event-driven, scalable, and cost-effective execution of specific tasks, like AI API calls.
  • Perplexity API: An advanced conversational AI service for real-time search, summarization, or sophisticated content generation.
  • DigitalOcean: A developer-friendly cloud platform offering Droplets and managed databases for straightforward and performant application hosting.

AdonisJS: The Robust API Gateway

AdonisJS https://adonisjs.com/ provides an elegant and opinionated framework for crafting secure and scalable web applications using TypeScript. Here, it will expose an endpoint that acts as an orchestrator, validating incoming requests before invoking our dedicated Azure Function for AI processing.

First, define an AdonisJS controller to manage the incoming user queries. This controller is responsible for validating the request payload and securely dispatching the query to our Azure Function.

// app/Controllers/Http/PerplexityController.ts
import { HttpContext } from '@adonisjs/core/http'
import env from '@adonisjs/core/env'
import axios from 'axios'

export default class PerplexityController {
  public async askAI({ request, response }: HttpContext) {
    const { query } = request.only(['query'])

    if (!query) {
      return response.badRequest({ message: 'Query parameter is required.' })
    }

    try {
      // Retrieve Azure Function URL and API Key from environment variables
      const azureFunctionUrl = env.get('AZURE_FUNCTION_URL')
      const azureFunctionApiKey = env.get('AZURE_FUNCTION_API_KEY')

      // Invoke the Azure Function with the user's query
      const { data } = await axios.post(
        azureFunctionUrl,
        { query },
        {
          headers: {
            'x-functions-key': azureFunctionApiKey, // Securely authenticate with Azure Function
            'Content-Type': 'application/json',
          },
        }
      )

      return response.ok(data)
    } catch (error) {
      console.error('Error invoking Azure Function:', error.message)
      return response.internalServerError({ message: 'Failed to process AI request through Azure Function.' })
    }
  }
}

Next, define a route in your AdonisJS application to expose this controller's action:

// start/routes.ts
import router from '@adonisjs/core/services/router'

router.post('api/ask', '#controllers/perplexity_controller.askAI')

Azure Functions: Serverless AI Orchestration

Azure Functions https://azure.microsoft.com/products/functions/ provide a highly scalable and cost-effective serverless execution environment, making them ideal for event-driven tasks such as making external API calls. This approach allows us to decouple AI processing logic from our main application, enabling independent scaling and efficient resource utilization for specific AI workloads.

Implement an HTTP-triggered Azure Function using TypeScript. This function will receive the query from AdonisJS, interact with the Perplexity API, and return the processed result.

// src/functions/askPerplexity.ts
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions'

interface PerplexityRequestPayload {
  query: string;
}

export async function askPerplexity(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  context.log(`HTTP trigger function processed request for URL "${request.url}"`)

  const body: PerplexityRequestPayload = await request.json()
  const query = body.query

  if (!query) {
    return {
      status: 400,
      jsonBody: { error: 'Please provide a \"query\" in the request body.' },
    }
  }

  try {
    // Retrieve Perplexity API key and URL from environment variables for security
    const perplexityApiKey = process.env.PERPLEXITY_API_KEY
    const perplexityApiUrl = process.env.PERPLEXITY_API_URL || 'https://api.perplexity.ai/chat/completions'

    const response = await fetch(perplexityApiUrl, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${perplexityApiKey}`, // Authenticate with Perplexity API
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'llama-3-8b-instruct', // Specify the desired Perplexity AI model
        messages: [{
          role: 'user',
          content: query,
        }],
        max_tokens: 500, // Limit the response length
      }),
    })

    if (!response.ok) {
      const errorData = await response.json()
      throw new Error(`Perplexity API error: ${response.status} - ${JSON.stringify(errorData)}`)
    }

    const data = await response.json()
    // Extract and return the AI's response content
    return { jsonBody: { response: data.choices[0].message.content } }

  } catch (error) {
    context.log(`Error calling Perplexity API: ${error.message}`)
    return {
      status: 500,
      jsonBody: { error: 'Failed to get response from Perplexity AI.' },
    }
  }
}

// Register the HTTP trigger with 'function' level authentication
app.http('askPerplexity', {
  methods: ['POST'],
  authLevel: 'function', // Requires an API key for invocation, enhancing security
  handler: askPerplexity,
})

Perplexity API: Intelligent Content Generation

The Perplexity API https://docs.perplexity.ai/ offers powerful conversational AI capabilities, making it excellent for tasks like generating summaries, answering complex questions, or creating dynamic content. By centralizing its invocation within an Azure Function, we effectively encapsulate AI logic, manage secrets securely, and ensure consistent interaction with the AI service.

Crucially, ensure your PERPLEXITY_API_KEY and PERPLEXITY_API_URL are securely configured as application settings in your Azure Function's deployment environment, not hardcoded in your source.

DigitalOcean: Simplified Deployment

DigitalOcean https://www.digitalocean.com/ provides a developer-friendly cloud infrastructure, making it an excellent choice for deploying AdonisJS applications. A Droplet (their virtual private server) combined with a managed PostgreSQL database offers a cost-effective, performant, and easily scalable hosting environment.

To deploy your AdonisJS application, provision a Droplet, install Node.js, and use a process manager like pm2 or Docker Compose to ensure your application runs continuously. Configure Nginx as a reverse proxy to efficiently serve your AdonisJS application to the public internet. Remember to set environment variables (AZURE_FUNCTION_URL, AZURE_FUNCTION_API_KEY) on your DigitalOcean Droplet for secure communication.

# On your DigitalOcean Droplet after SSH access
# 1. Install Node.js, npm, and pm2 (e.g., sudo npm install -g pm2)
# 2. Clone your AdonisJS repository
git clone https://github.com/your-username/your-adonisjs-app.git
cd your-adonisjs-app

# 3. Install dependencies and build the project
npm install
npm run build # Compiles TypeScript to JavaScript

# 4. Set environment variables (e.g., via .env file or systemd service)
# export AZURE_FUNCTION_URL="https://your-function-app.azurewebsites.net/api/askPerplexity"
# export AZURE_FUNCTION_API_KEY="YOUR_AZURE_FUNCTION_KEY"

# 5. Start the application with pm2
pm2 start build/server.js --name "adonis-app"
pm2 save # Persist pm2 processes across reboots

# 6. Configure Nginx as a reverse proxy (example snippet, full config needed)
# sudo nano /etc/nginx/sites-available/your-domain.conf
# server {
#     listen 80;
#     server_name your-domain.com www.your-domain.com;
#     location / {
#         proxy_pass http://localhost:3333; # AdonisJS default port
#         proxy_http_version 1.1;
#         proxy_set_header Upgrade $http_upgrade;
#         proxy_set_header Connection 'upgrade';
#         proxy_set_header Host $host;
#         proxy_cache_bypass $http_upgrade;
#     }
# }
# sudo ln -s /etc/nginx/sites-available/your-domain.conf /etc/nginx/sites-enabled/
# sudo nginx -t && sudo systemctl restart nginx

Conclusion

By strategically integrating AdonisJS for robust API management, Azure Functions for scalable, serverless AI processing with Perplexity API, and DigitalOcean for streamlined and cost-effective deployment, developers can construct powerful, intelligent, and highly maintainable web applications. This modern architecture provides clear separation of concerns, leveraging the unique strengths of each platform to deliver a high-performance, resilient, and engaging user experience in 2026 and beyond.

cd..→back to blog