Beyond-Basics: Best Practices for .do SDK Integration

Unlock the Power of Agentic Workflows in Your Applications

(For Developers)

In today's fast-paced digital landscape, integrating intelligent automation and AI capabilities into your applications is no longer a luxury – it's a necessity. The .do platform offers a powerful solution with its innovative Agentic Workflows, allowing you to automate complex tasks, integrate AI models, and deliver services-as-software with unprecedented ease.

But how do you harness this power within your existing applications? Enter the .do SDK.

The @dot-do/sdk is your gateway to seamlessly embedding .do Agentic Workflows directly into your software. It simplifies the integration process, allowing you to focus on building rather than grappling with complex API calls.

Build Smarter with the .do SDK

The .do SDK empowers developers to integrate agentic workflows into their applications seamlessly. Imagine easily automating text summarization, content generation, data processing, or interacting with a myriad of AI services – all through simple API calls wrapped in an intuitive SDK.

import { Agent } from "@dot-do/sdk";

const agent = new Agent("your-api-key");

async function summarizeText(text: string) {
  const response = await agent.do("summarize", { text });
  console.log(response.data);
}

summarizeText("Your long text here...");

This simple TypeScript example demonstrates how effortlessly you can leverage a "summarize" workflow from your application. The Agent class handles the heavy lifting, connecting to the .do platform and executing your chosen workflow.

Best Practices for .do SDK Integration

While the .do SDK is designed for simplicity, following best practices can significantly enhance your integration experience, improve application performance, and ensure scalability.

1. Secure Your API Keys

Your API key is the credential that authenticates your application with the .do platform. Treat it like a password.

• Environment Variables: Never hardcode your API key directly in your codebase. Instead, use environment variables, especially in production environments. This keeps your key out of version control and allows for easy rotation.
• Server-Side Usage: For most use cases, it's best to use the SDK on the server-side (Node.js). If you must use it on the frontend, ensure your API calls are proxied through your backend to avoid exposing your API key directly in the client-side code.

2. Handle Asynchronous Operations Gracefully

Agentic workflows often involve network requests and computational tasks, making them inherently asynchronous.

• async/await: As shown in the example, use async/await for clean, readable asynchronous code. This makes it easier to understand the flow and handle potential errors.
• Error Handling: Always wrap your SDK calls in try...catch blocks to gracefully handle network issues, API errors, or unexpected responses from the workflow. Provide meaningful feedback to your users or log errors for debugging.

try {
  const response = await agent.do("summarize", { text });
  // Process successful response
} catch (error) {
  console.error("Error summarizing text:", error);
  // Handle error, e.g., show a user-friendly message
}

3. Implement Caching Strategically

If your application frequently calls the same .do workflow with identical inputs and the output is relatively static, consider implementing caching.

• Reduce Latency: Caching can significantly reduce response times by serving data from a local cache instead of making a new network request to the .do platform.
• Manage Rate Limits: While .do is robust, caching can help you stay within potential rate limits by reducing redundant calls.
• Cache Invalidation: Implement a clear strategy for invalidating cached data when the underlying workflow logic or input data changes.

4. Monitor and Log Your Workflow Interactions

Visibility into how your application interacts with .do workflows is crucial for debugging, performance optimization, and understanding usage patterns.

• Logging: Log successful workflow calls, errors, response times, and key parameters. This data is invaluable for troubleshooting and auditing.
• Metrics: Integrate with your existing monitoring solutions to track metrics like the number of successful calls, error rates, and average response times for .do workflows.

5. Optimize Payload Sizes

While .do workflows can handle substantial data, efficiency is key.

• Send Only What's Needed: Only send the necessary data to the workflow. Avoid sending large, irrelevant datasets if only a small portion is required for processing.
• Compression: If dealing with very large text or binary data, consider if compression techniques can be applied before sending (and de-compression after receiving).

Frequently Asked Questions (FAQs) about the @dot-do/sdk

What is the @dot-do/sdk?

The @dot-do/sdk is a Software Development Kit that allows you to easily integrate and interact with .do Agentic Workflows directly within your applications using simple APIs and SDKs.

How do I install the SDK?

You can install the SDK using popular package managers like npm or yarn:

npm install @dot-do/sdk or yarn add @dot-do/sdk

How do I use the SDK to interact with .do workflows?

The core of the SDK is the Agent class, which allows you to call .do workflows by name and pass in necessary parameters. The SDK handles the communication and returns the results from the workflow.

Can I use the SDK in both backend and frontend applications?

Yes, the SDK is designed to be used in both backend (Node.js) and frontend (browser) environments.

Conclusion

The .do SDK (sdk.do) opens up a world of possibilities for integrating sophisticated agentic workflows and AI capabilities into your applications with remarkable ease. By adhering to these best practices, you can ensure a robust, efficient, and scalable integration, empowering your applications to do more, smarter. Start building today and unlock the full potential of .do Agentic Workflows!