# Generative Pipelines

The concept of generative pipelines references the integration of generative services with other inputs and outputs, including application services, hardware, human beings, or just about anything you can think of. \
\
For example, let's review a customer complaint process within our bicycle rental application. Where a customer tried to withdraw funds, but the customer is reporting there was a system outage for a week, called customer 12 times, and was still unable to withdraw their money. A generative pipeline could automate that review process to:

* Consume your [business logic](/gdf-full-stack-engineering/guidance.md) of which customer communications qualify as a complaint
* Analyze the customer complaint and return a recommendation based actions you permit your AI to perform on your behalf.
* Use that recommendation to update other systems in your organization through APIs.
* Use APIs to communicate out to the customer the status of their complaint.

{% hint style="info" %}
[Prompt stores](/gdf-full-stack-engineering/prompting/prompt-stores.md) can make your prompts much more efficient.
{% endhint %}

Here's a sample implementation that connects ChatGPT, Salesforce, and Twilio as part of the complaint resolution process:

{% code overflow="wrap" %}

```javascript
const axios = require("axios");
const fs = require("fs");

// ChatGPT: Get AI-generated response and recommended action
async function getChatGptResponse(complaintText) {
  const rules = "your_business_logic(best provided in if/then format)";
  const acceptableActions = "refund, apologize, escalate"
  const apiKey = "your_openai_api_key";
  const prompt = `Analyze the following customer complaint based on the rules provided and provide a recommended action of the one of the following actions: "${acceptableActions}". Complaint: "${complaintText}". Only return recommended action.`;

  const response = await axios.post(
    "https://api.openai.com/v1/engines/davinci-codex/completions",
    {
      prompt: prompt,
      max_tokens: 100,
      n: 1,
      stop: null,
      temperature: 0.7,
    },
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${apiKey}`,
      },
    }
  );

  const aiResponse = response.data.choices[0].text.trim();
  const recommendedAction = parseRecommendedAction(aiResponse);
  return { aiResponse, recommendedAction };
}

// Parse the recommended action from the AI-generated response
function parseRecommendedAction(aiResponse) {
  const possibleActions = ["refund", "apologize, escalate"];
  let recommendedAction = "";

  possibleActions.forEach((action) => {
    if (aiResponse.toLowerCase().includes(action)) {
      recommendedAction = action;
    }
  });

  return recommendedAction;
}

// Main complaint resolution process
async function resolveComplaint(complaintText, customerId, chargeId) {
  const { aiResponse, recommendedAction } = await getChatGptResponse(complaintText);
  const caseId = await createSalesforceCase({ Subject: complaintText, CustomerId: customerId });
  const emailContent = aiResponse;

  if (recommendedAction === "refund") {
    const refundAmount = calculateRefundAmount(chargeId);
    await issueRefund(chargeId, refundAmount);
    emailContent += `\n\nWe have issued a refund of ${refundAmount} to your account.`;
  }

  await sendEmail(customerId, "Complaint Resolution", emailContent);
}
```

{% endcode %}

In this example, we first call the `getChatGptResponse` function, which sends the customer complaint text to the ChatGPT API and receives an AI-generated response and recommended action. Based on the recommended action, we can create a case in Salesforce using the `createSalesforceCase` function, issue a refund with the `issueRefund` function (if necessary), and finally send an email to the customer using the `sendEmail` function.

Please note that you'll need to replace the placeholders like `"your_openai_api_key"` with your actual API keys, and implement the `parseRecommendedAction` function to extract the recommended action from the AI-generated response according to your specific use case.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.gdf.ai/gdf-full-stack-engineering/generative-pipelines.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.