Integrate Salesforce and Gong with ChatGPT: A Developer's Guide to Powerful GPT Actions

Unlock the potential of ChatGPT by connecting it to your Salesforce and Gong accounts. This guide provides developers with the instructions and resources needed to build middleware that bridges these powerful platforms. By leveraging Salesforce GPT actions, you can empower users to access critical customer data and conversation insights directly within ChatGPT, saving time and improving decision-making. This will make it easier than ever to set up Salesforce GPT actions.

Why Integrate Salesforce and Gong with ChatGPT?

• Maximize Sales Efficiency: Instantly retrieve account details and call transcripts for better meeting preparation.
• Improve Customer Understanding: Get AI-powered summaries and insights based on proven sales methodologies.
• Streamline Workflows: Access essential information without switching between multiple applications.

Example Business Use Case: Preparing for a Customer Meeting with Salesforce GPT action

Imagine a sales representative preparing for a crucial customer meeting. Integrating Salesforce and Gong with ChatGPT allows them to:

1. Quickly retrieve relevant account details from Salesforce.
2. Access recent Gong call transcripts.
3. Receive AI-generated summaries and insights structured around sales methodologies like MEDPICC or SPICED.

This process provides a clear, actionable understanding of the customer's needs and lays the foundation for successful sales strategies.

Prerequisites Before Building Salesforce GPT action

Before you begin, make sure you have the following in place:

• Familiarity with GPT Actions: Understand the basics of building and using GPT Actions.
• Salesforce Access: Access to a Salesforce account.
• Gong API Key: A valid API key for accessing Gong data.
• Middleware Environment: Set up an environment for deploying a serverless function (AWS, Azure Functions, or Google Cloud Function).

Step-by-Step Guide to Building Your Integration

1. Setting up the Salesforce GPT Action

Refer to the "GPT Actions library - Salesforce" for detailed instructions on creating a GPT Action for Salesforce. Pay close attention to:

• Application Information: Understand the core concepts within Salesforce relevant to the integration.
• Authentication: Learn how to create a Connected App in Salesforce and configure OAuth for secure communication between Salesforce and ChatGPT.

2. Crafting the Middleware GPT Action

The middleware facilitates data exchange between ChatGPT and Gong. Refer to any of the following cookbooks for setting up your middleware:

• GPT Actions library (Middleware) - AWS
• GPT Actions library (Middleware) - Azure Functions
• GPT Actions library (Middleware) - Google Cloud Function

Example: Azure Functions Implementation

Here's a sample Azure Function (JavaScript) to retrieve call transcripts from Gong:

const { app } = require('@azure/functions');
const axios = require('axios');

const GONG_API_BASE_URL = "https://api.gong.io/v2";
const GONG_API_KEY = process.env.GONG_API_KEY;

app.http('callTranscripts', {
  methods: ['POST'],
  authLevel: 'function',
  handler: async (request, context) => {
    try {
      const body = await request.json();
      const callIds = body.callIds;

      if (!Array.isArray(callIds) || callIds.length === 0) {
        return {
          status: 400,
          body: "Please provide call IDs in the 'callIds' array."
        };
      }

      // Fetch call transcripts
      const transcriptPayload = { filter: { callIds } };
      const transcriptResponse = await axios.post(`${GONG_API_BASE_URL}/calls/transcript`, transcriptPayload, {
        headers: {
          'Authorization': `Basic ${GONG_API_KEY}`,
          'Content-Type': 'application/json'
        }
      });

      const transcriptData = transcriptResponse.data;

      // Fetch extensive call details
      const extensivePayload = {
        filter: { callIds },
        contentSelector: {
          exposedFields: { parties: true }
        }
      };

      const extensiveResponse = await axios.post(`${GONG_API_BASE_URL}/calls/extensive`, extensivePayload, {
        headers: {
          'Authorization': `Basic ${GONG_API_KEY}`,
          'Content-Type': 'application/json'
        }
      });

      const extensiveData = extensiveResponse.data;
  
    const callMetaMap = {};
      extensiveData.calls.forEach(call => {
          callMetaMap[call.metaData.id] = {
              title: call.metaData.title,
              started: call.metaData.started,
              duration: call.metaData.duration,
              url: call.metaData.url,
              speakers: {}
          };
  
          call.parties.forEach(party => {
              callMetaMap[call.metaData.id].speakers[party.speakerId] = party.name;
          });
      });
  
      transcriptData.callTranscripts.forEach(call => {
          const meta = callMetaMap[call.callId];
          if (!meta) {
              throw new Error(`Metadata for callId ${call.callId} not found.`);
          }
  
          let content = '';
          call.transcript.forEach(segment => {
              const speakerName = meta.speakers[segment.speakerId] || "Unknown Speaker";
  
              const sentences = segment.sentences.map(sentence => sentence.text).join(' ');
              content += `${speakerName}: ${sentences} \n\n `;
          });
  
          call.title = meta.title;
          call.started = meta.started;
          call.duration = meta.duration;
          call.url = meta.url;
          call.content = content;
  
          delete call.transcript;
      });
  
      return {
          status: 200,
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(transcriptData)
      };
  } catch (error) {
      context.log('[ERROR]', "Error processing request:", error);

      return {
          status: error.response?.status || 500,
          body: {
              message: "An error occurred while fetching or processing call data.",
              details: error.response?.data || error.message
          }
      };
  }
}
});

Ensure your package.json includes the necessary dependencies:

"dependencies": {
    "@azure/functions": "^4.0.0",
    "axios": "^1.7.7"
}

3. Configuring ChatGPT with Custom Actions

1. Custom GPT Instructions: Provide clear instructions to your Custom GPT, guiding it to interact with Salesforce and the middleware.
2. Salesforce Custom Action Schema: Define the OpenAPI schema for the Salesforce action.

4. Defining OpenAPI Schema for Salesforce and Gong Actions

• Salesforce:

  openapi: 3.1.0
  info:
    title: Salesforce API
    version: 1.0.0
    description: API for accessing Salesforce sObjects and executing queries.
  servers:
    - url: https://<subdomain>.my.salesforce.com/services/data/v59.0
      description: Salesforce API server
  paths:
    /query:
      get:
        summary: Execute a SOQL Query
        description: Executes a given SOQL query and returns the results.
        operationId: executeSOQLQuery
        parameters:
          - name: q
            in: query
            description: The SOQL query string to be executed.
            required: true
            schema:
              type: string
        responses:
          '200':
            description: Query executed successfully.
            content:
              application/json:
                schema:
                  $ref: '#/components/schemas/QueryResult'
  
    /search:
      get:
        summary: Execute a SOSL Search
        description: Executes a SOSL search based on the given query and returns matching records.
        operationId: executeSOSLSearch
        parameters:
          - name: q
            in: query
            description: The SOSL search string (e.g., 'FIND {Acme}').
            required: true
            schema:
              type: string
        responses:
          '200':
            description: Search executed successfully.
            content:
              application/json:
                schema:
                  $ref: '#/components/schemas/SearchResult'
  components:
    schemas:
      QueryResult:
        type: object
        description: Result of a SOQL query.
        properties:
          totalSize:
            type: integer
            description: The total number of records matching the query.
          done:
            type: boolean
            description: Indicates if the query result includes all records.
          records:
            type: array
            description: The list of records returned by the query.
            items:
              $ref: '#/components/schemas/SObject'
  
      SearchResult:
        type: object
        description: Result of a SOSL search.
        properties:
          searchRecords:
            type: array
            description: The list of records matching the search query.
            items:
              $ref: '#/components/schemas/SObject'
  
      SObject:
        type: object
        description: A Salesforce sObject, which represents a database table record.
        properties:
          attributes:
            type: object
            description: Metadata about the sObject, such as type and URL.
            properties:
              type:
                type: string
                description: The sObject type.
              url:
                type: string
                description: The URL of the record.
          Id:
            type: string
            description: The unique identifier for the sObject.
          additionalProperties: true
  

  Copy
• Middleware (Gong):

  openapi: 3.1.0
  info:
    title: Call Transcripts API
    description: API to retrieve call transcripts and associated metadata by specific call IDs.
    version: 1.0.1
  servers:
    - url: https://<subdomain>.azurewebsites.net/api
      description: Production server
  paths:
    /callTranscripts:
      post:
        operationId: getTranscriptsByCallIds
        x-openai-isConsequential: false
        summary: Retrieve call transcripts by call IDs
        description: Fetches specific call transcripts based on the provided call IDs in the request body.
        requestBody:
          required: true
          content:
            application/json:
              schema:
                type: object
                properties:
                  callIds:
                    type: array
                    description: List of call IDs for which transcripts need to be fetched.
                    items:
                      type: string
                required:
                  - callIds
        responses:
          '200':
            description: A successful response containing the requested call transcripts and metadata.
            content:
              application/json:
                schema:
                  type: object
                  properties:
                    requestId:
                      type: string
                      description: Unique request identifier.
                    records:
                      type: object
                      description: Metadata about the pagination.
                      properties:
                        totalRecords:
                          type: integer
                          description: Total number of records available.
                        currentPageSize:
                          type: integer
                          description: Number of records in the current page.
                        currentPageNumber:
                          type: integer
                          description: The current page number.
                    callTranscripts:
                      type: array
                      description: List of call transcripts.
                      items:
                        type: object
                        properties:
                          callId:
                            type: string
                            description: Unique identifier for the call.
                          title:
                            type: string
                            description: Title of the call or meeting.
                          started:
                            type: string
                            format: date-time
                            description: Timestamp when the call started.
                          duration:
                            type: integer
                            description: Duration of the call in seconds.
                          url:
                            type: string
                            format: uri
                            description: URL to access the call recording or details.
                          content:
                            type: string
                            description: Transcript content of the call.
          '400':
            description: Invalid request. Possibly due to missing or invalid `callIds` parameter.
          '401':
            description: Unauthorized access due to invalid or missing API key.
          '500':
            description: Internal server error.
  

  Copy

ChatGPT Instruction Examples

Here are some example instructions you can provide to ChatGPT:

# Trigger: User enters the name of an account that they want to prepare for

# Steps:

1. Retrieve Account Names - Make a call to the executeSOSLSearch custom action searching for a Salesforce Account with that name (SOSL). Retrieve up to 5 accounts.

   Example Query: FIND {Acme} IN ALL FIELDS RETURNING Account(Id, Name) LIMIT 5

2. Show the accounts in this format - Account Name - salesforceID. Ask the user to confirm which account they are interested in.

3. Get Gong Call IDs for the account - For the confirmed account, make a call to executeSOQLQuery to get all the Gong Call IDs.

   Example Query: SELECT XXX, YYY, ZZZ FROM Gong__Gong_Call__c WHERE Gong__Primary_Account__c = '<AccountId>' ORDER BY Gong__Call_Start__c DESC LIMIT 2

4. Pass in the callIds to getTranscriptsByCallIds

Summarize Call Example

# Trigger User says "Summarize call"

# Steps

Use both the transcripts and provide the following output

## Account Name

Print out the account name

## Details of calls

Please list the calls for which you retrieved the transcripts along with their dates and attendees in this table format:

Headers: , , ,

## Recommended Meeting Focus Areas:

Analyze the transcripts to identify themes, challenges, and opportunities. Based on this, generate a list of recommended focus areas for the next meeting. These should be actionable and specific to the client’s needs. Explain why each item should be a meeting focus.

For each of the following insights, specify which call and date you sourced the insight from:

• Metrics: Quantifiable outcomes the customer is trying to achieve.
• Economic Buyer: Identify if the true economic decision-maker was mentioned or involved.
• Decision Criteria: What are the key factors the customer will use to evaluate solutions?
• Decision Process: Describe how the customer plans to make the buying decision.
• Paper Process: Any mention of legal, procurement, compliance, or contract-related steps.
• Identify Pain: Highlight the core business challenges the customer is facing.
• Champion: Is there someone internally who is championing our solution?
• (Optional) Competition: Mention any competing vendors, internal builds, or alternative solutions discussed.

Customization

Replace the query in step 3 to retrieve the Gong Call IDs from your custom Salesforce object. Remember to create two separate actions - one connecting to Salesforce and the other connecting to the middleware that calls the Gong APIs.

Conclusion

By integrating Salesforce and Gong with ChatGPT, you can revolutionize how sales teams access and utilize critical customer information. This guide provides a comprehensive overview of the development process, empowering you to build powerful and efficient GPT Actions that drive business success.