Coveo Articles / Blogs / Perficient

Integrate Coveo Atomic CLI-Based Hosted Search Page into Adobe Experience Manager (AEM)

Ashwini Bhave — Wed, 18 Jun 2025 06:20:24 +0000

Getting Started with Coveo Atomic CLI

This section explains how to install, configure, and deploy a Coveo Atomic project using the Coveo CLI

Install the CLI

To get started, install the Coveo CLI globally with npm:

npm install -g @coveo/cli

To ensure you’re always using the latest version, update it anytime with:

npm update -g @coveo/cli

Authentication

Once the CLI is installed, you will need to authenticate to your coveo organization. Use the following command, replacing the placeholders with your specific organization details:

coveo auth:login --environment=prod --organization= --region=

For example:

coveo auth:login --environment=prod --organization=blogtestorgiekhkuqk --region=us

Initialize an Coveo Atomic CLI Project

After logging in, initialize a new atomic project by running:

coveo atomic:init  --type=app

For example:

coveo atomic:init atomicInterface  --type=app

Building and Deploying the Project

Once the project is ready, build the application:

npm run build

This command compiles your code and prepares it for deployment. It creates a production-ready build inside the dist/ folder.

Then deploy your interface to Coveo using:

coveo ui:deploy

After deployment, your search interface will be hosted on Coveo’s infrastructure, ready to embed anywhere—like Adobe

Using and Initializing Atomic-Hosted-Page

This section guides you through using and initializing the Atomic-Hosted-Page component of your Coveo project.

Use Atomic-Hosted-Page

If you have customized your Atomic search page locally and deployed it to the Coveo infrastructure, then it will be listed in the Custom Deployment tab of the Search Pages (platform-ca | platform-eu | platform-au) page of the Administration Console. You can use the atomic-hosted-page component to consume it from anywhere on the web.

Initialize Atomic-Hosted-Page

Once you have installed the atomic-hosted-page or atomic-hosted-ui web component, you’ll need to add a script like the following to initialize the atomic-hosted-page component:

In this script, replace the placeholders with coveo specific details:

(string) is an API key or platform token that grants the View all access level on the Search Pages domain in the target Coveo organization.
(string) is the unique identifier of your organization (for example, mycoveoorganizationa1b23c).
(string) is the unique identifier of the hosted page, which you can copy from the Administration Console.

Steps to Embed in Adobe Experience Manager (AEM)

Login to Adobe AEM Author Instance
Example URL: https://author-555.adobeaemcloud.com/
Navigate to the AEM Sites Console
Go to:https://author-555.adobeaemcloud.com/sites.html/content/blog/us/en/search-results
The Sites Console in AEM, used to manage your website’s pages and structure.
Create or Select the Page
- Create new or use an existing page, for example: search-results.
- Select the page’s checkbox → click Edit (top toolbar).
- You’ll be redirected to the Page Editor: https://author-555.adobeaemcloud.com/editor.html/content/blog/us/en/search-results.html.
Embed the Coveo Script:
In the Page Editor, open the Content Tree on the left, select Layout Container, click the Configure (wrench icon) button
Choose Embed Type
Choose Embed → iFrame. Paste your script inside the iFrame.
Preview and Publish the Page

Click Page Information icon → Publish Page, the alert confirms that the page will be live
View the Published Page
Example URL:http://localhost:4502/content/blog/us/en/search-results.html

That’s it—you’ve successfully embedded your Coveo Atomic CLI-based Hosted Search Page inside Adobe!

References:

Use a hosted page in your infrastructure | Coveo Atomic

Reimagining Find Care: How AI is Transforming the Digital Healthcare Experience [Webinar]

Lysa Young-Bates — Wed, 21 May 2025 18:02:34 +0000

Choosing a provider is one of the most personal decisions in healthcare. Yet, one in five consumers abandon healthcare organizations due to poor digital experiences.

In our recent webinar “Reimagining Find Care: How AI is Transforming the Digital Healthcare Experience,” healthcare leaders explored how AI-powered search, recommendations, and personalization are redefining access to care. Hosts Tara Becker, Perficient principal of healthcare and life sciences, and Mike Raley, Coveo SVP of marketing, detailed why this matters more than ever for health systems seeking to grow, compete, and deliver better outcomes.

Below, we break down the most important takeaways from the session:

1. Find Care Is the New Front Door—and It Must Feel Like Commerce

Healthcare is increasingly judged by the same standards as consumer brands like Door Dash and Expedia. Patients expect to search, compare, and book appointments as easily as they would a hotel or a ride share.

Key Insights:

Digital access is a revenue driver. A seamless Find Care experience builds trust, drives patient acquisition, and reduces leakage.
Friction leads to churn. 41% of consumers consider switching providers if the digital experience doesn’t meet expectations.
Convenience drives action. Patients want to search by criteria that matters to them—location, gender, language, availability—and they want to book instantly.

Perficient’s Access to Care research study quantifies the direct impacts on business and health outcomes due to friction in the care journey.

2. AI-Powered Search and Personalization Are Game-Changers

AI relevance platforms like Coveo are transforming how patients find care. By unifying content, provider data, and real-time intent signals, AI enables hyper-personalized, intuitive experiences.

What AI Enables:

Smart search that understands intent. Patients can type “family doctor near me” and instantly see relevant, bookable options.
Dynamic filtering and recommendations. AI surfaces providers based on availability, insurance, and patient preferences.
Generative answers grounded in trusted content. Patients get accurate, contextual responses—without hallucinations.

3. Strategy First: Align Digital Investments with Business Outcomes

Technology alone isn’t enough. A successful Find Care transformation starts with a clear strategy aligned to organizational goals.

Strategic Best Practices:

Define your North Star. Establish KPIs that serve as success criteria for your new Find Care experience and prioritize service lines (e.g., cardiology, oncology, primary care) that drive revenue and impact.
Map patient journeys. Understand your personas (e.g., caregivers, chronic patients), their preferences, expectations, journeys, and friction points. Design a seamless experience that removes obstacles and guides healthcare consumers to conversion.
Audit and optimize content. Ensure provider profiles are robust and updated. Service line pages need to be relevant, actionable, and conversion-focused.

4. Build a Scalable, Interoperable Tech Stack

Find Care must integrate seamlessly with your existing systems—EHR, CRM, DXP, and more. Flexibility and interoperability are key.

Technical Considerations:

Platform-agnostic design. Because our AI-powered Find Care solution is DXP-agnostic, it can be tailored for your organization and preferred martech stack, whether that includes Adobe, Sitecore, Acquia, Optimizely, WordPress, etc.
Unified data layer. Connect provider directories, appointment systems, and content repositories so the most relevant information is delivered to users.
HIPAA-compliant AI. Ensure patient data is secure while delivering personalized experiences.

5. Measure What Matters: From Clicks to Conversions

Digital success must be measured in business terms—not just traffic. Establish an outcomes dashboard that ties digital engagement to revenue, access, and health outcomes—and report it to the C-suite.

Metrics That Matter:

Appointment conversions and completions
Search abandonment and content gaps
Patient satisfaction and Net Promoter Score (NPS)
Operational efficiency (e.g., reduced call volume, fewer no-shows)

6. Start Small, Scale Smart

You don’t need to do everything at once. Begin with priority, high-impact experiences and service lines, then iterate.

A Phased Approach:

Phase 1: Define a patient-centric Find Care blueprint.
Phase 2: Implement Coveo for a powerfully integrated, unified search experience.
Phase 3: Launch online appointment scheduling for primary care and urgent care.
Phase 4: Expand to specialty services and guided journeys.
Phase 5: Layer in generative AI and conversational experiences.

Final Thought: Find Care Is Not Just a Feature—It’s a Strategic Imperative

In an increasingly competitive and crowded health care marketplace, Find Care is your digital front door, your commerce engine, and your trust builder. AI-powered experiences are no longer optional—they’re expected.

Healthcare leaders who invest in intelligent, patient-centric digital pathways will not only win market share—they’ll improve outcomes, reduce costs, and build lasting loyalty.

Ready to Reimagine Your Find Care Experience?

If you’re exploring how to modernize your digital front door, consider starting with a strategic assessment. Align your goals, audit your content, and evaluate your tech stack. The path to better outcomes starts with a smarter, simpler way to help patients find care.

We combine strategy, industry best practices, and technology expertise to deliver award-winning results for leading healthcare organizations.

Business Transformation: Activate strategy for transformative outcomes and health experiences.
Modernization: Maximize technology to drive health innovation, efficiency, and interoperability.
Data + Analytics: Power enterprise agility and accelerate healthcare insights.
Consumer Experience: Connect, ease, and elevate impactful health journeys.

Our approach to designing and implementing AI and machine learning (ML) solutions promotes secure and responsible adoption and ensures demonstrated and sustainable business value. We are one of a select group of Coveo Platinum partners helping brands design, architect, and implement modern intelligent search solutions that empower users to be more successful and deliver a winning customer experience.

Discover why we have been trusted by the 10 largest health systems and the 10 largest health insurers in the U.S.  Explore our healthcare expertise and contact us to learn more.

Watch the On-Demand Webinar Now

Coveo Recognizes Perficient Colleagues as MVPs in 2025

Susan Welton — Mon, 21 Apr 2025 18:56:10 +0000

We’re excited to share that Coveo has honored seven of our Perficient colleagues with the prestigious title of Coveo Most Valuable Professional.

To be considered for the recognition of Coveo MVP, applicants must have demonstrated exceptional skill in utilizing Coveo solutions, significantly contributing to the success of our mutual customers. In addition to platform mastery and deployment expertise, MVPs are evaluated based on content creation, thought leadership, product input, and creative positioning.

“Our team has consistently achieved new milestones and established a standard of excellence in our Coveo practice at Perficient. The seven Coveo MVP certifications we have earned reflect our commitment, collaboration, and unwavering drive for innovation,” said Michael Patterson, Managing Director at Perficient.

Our 2025 MVPs

Huge congratulations to our seven well-deserving Coveo MVPs:

Eric Immermann, Director
Zachary Fischer, Senior Solutions Architect
Steven Wu, Solutions Architect
Kristofer Quinn, Senior Technical Architect
Nicolas Bernier, Senior Technical Architect
Rohit Patidar, Lead Technical Consultant
Fernando Rodriguez Rojas, Lead Technical Consultant

This is Eric Immermann’s 5th Coveo MVP recognition. “Receiving the Coveo MVP recognition again is a wonderful testament to the expertise and dedication my team and I bring to ensuring our clients maximize the benefits and usage of the Coveo platform. Congratulations to my MVP colleagues at Perficient for your ongoing commitment to showcasing key thought leadership and technical prowess to strengthen the Perficient + Coveo partnership.”

Learn More About Our Coveo Practice

Our Coveo Practice helps brands design, architect and implement modern intelligent search solutions that empower users to be more successful in delivering a winning customer experience. As a Platinum partner and three-time Accelerator Award recipient, we pride ourselves on providing unique, innovative solutions to our clients.

To learn more about Perficient’s Coveo solutions, visit our Coveo partner page,  read our Coveo blogs and follow us on LinkedIn and Twitter.

ADI | Snap One and Perficient Win Coveo Relevance Accelerator Award

Susan Welton — Thu, 13 Mar 2025 15:31:19 +0000

Perficient is excited to announce we’ve won Coveo’s exclusive partner award for the third time since inception! The Accelerator Award commemorates a Coveo partner and customer that worked together and exhibited deep knowledge and technical expertise and clearly delivered value-driven business outcomes.

A Coveo platinum partner with 100+ Coveo consultants globally, our award-winning work in collaboration with ADI | Snap One paved the way for increased conversions and purchases with fewer rules while improving employee efficiency. Coveo’s Merchandising Hub and dashboards provide ADI | Snap One with a single, centralized location to seamlessly understand and better service customers. 

This award highlights the outstanding efforts and achievements our team delivers using the Coveo platform to accelerate value-driven business outcomes for our clients. A big thank you to our client, ADI | Snap One. Our joint success is a result of the true collaborative spirit you brought to the project and fostered among your team. And to Eric Immermann, Director Enterprise Search, Zachary Fischer, Senior Solutions Architect, and Kyla Faust, Alliance Manager, at Perficient, we are grateful for your dedication to the Coveo partnership, and to the entire team for their ongoing collaboration in ensuring the success of our joint customers.

“We are honored to receive the Coveo Accelerator Award, which reflects the strength of our partnership with Coveo and ADI | Snap One, said Michael Patterson” Managing Director, Data and Analytics. “This recognition reinforces our shared commitment to innovation, and we are excited about the opportunities that lie ahead. We appreciate the support and collaboration from the Coveo team, which has been instrumental in our success.”

Our expertise across various technologies and platforms allows us to effortlessly integrate intelligent search with numerous enterprise applications, unlocking valuable information and transforming your business. By utilizing the top features from leading industry platforms, we deliver innovative solutions tailored to the unique needs of each client. With Coveo, you can anticipate tangible benefits such as enhanced productivity, better customer satisfaction, and increased revenue.

“I am so proud of this team and humbled to be recognized by Coveo for the delivery of value-driven business outcomes,” said Eric Immermann. “Coveo’s platform allows us to rapidly deploy personalized and highly relevant commerce, knowledge, and generative experiences. By collaborating with Coveo, we can bring cutting edge and holistic implementations to our customers.”

Boosting Coveo Smart Snippets Machine Learning Model with Custom Context-Driven Responses

Ashwini Bhave — Wed, 04 Dec 2024 19:03:56 +0000

In the world of search, delivering accurate and relevant answers quickly is key to enhancing user experience. Coveo’s Smart Snippets already provide users with the most relevant information directly on the results page, saving time and effort. But what if we could push this functionality further?

In this post, I’ll walk you through a custom feature I’ve developed for Coveo Smart Snippets. I’ve integrated custom context into the model by setting specific context rules. This has influenced how Smart Snippets respond, tailoring them even more precisely to user needs. This custom enhancement ensures that the snippets not only show relevant content but do so in a way that is fine-tuned based on the exact query context, delivering an even smarter search experience.

Smart Snippet Model in Coveo

The Coveo Machine Learning Smart Snippets model shows users direct answers to their questions on the search results page. Instead of clicking on links, users can quickly see the most relevant answer right there.
The Smart Snippet scans the search results, picks the most relevant one, and displays it at the top of the page with the important content highlighted.
It also suggests related questions or topics in a “People also ask” section so users can explore more without leaving the results page

Concrete Scenario

Imagine you run a big online store where customers often search for details about products, such as their features, reviews, or prices.

Without Smart Snippets: When someone searches for “wireless headphones,” they might see a generic preview of the product page. This preview might not show specific details like features or reviews, so users might have to click through the page to find what they need.

With Smart Snippets: When someone searches for “wireless headphones,” the Smart Snippet Model provides a preview that highlights the key features, latest reviews, or pricing details directly in the search results. This way, users can see important information immediately without visiting the product page.

Example: If someone searches for “wireless headphone features,” the Smart Snippet Model will ensure that the search result preview shows the most relevant details about the headphones’ features. This helps users quickly find the information they seek and decide if the product is right for them.

Setting Up the Smart Snippet Model in Coveo Admin Console

Note: Before starting, you should have the required license to create a model of this type.

Access Coveo Admin Console: Log in to Coveo Admin Console with the necessary permissions.
Navigate to Recommendations: In the left-hand menu, click “models” under the “Machine Learning” section.
Create a New Model: Click the “Add Model” button to start the setup process and select the “Smart Snippets”.

In this step, you must choose the specific sources containing the items you want the model to learn from. This helps the model understand which information to use when training.

In this step, you can specify the metadata field, but it’s optional and can be skipped.

This step is also optional and can be skipped for now, but you can exclude CSS properties.

In this step, provide a name for your model and click “Start Building” to begin creating it.

You’ll see the status of your smart snippet model as “Build in Progress.”

Once the model finishes building, it will be marked as ready for association.
Create a query pipeline: To utilize the Smart Snippets model, you need to create a dedicated Query Pipeline for proper association
Create Hosted Search Page: To implement the Smart Snippets model in the UI, follow these steps:
- Go to the ‘Search’ menu.
- Select ‘Search Page.’
- Click ‘Add Search Page.’
- Access the ‘Classic Interface Editor.’
- Enter the ‘Page Name’ and ‘HTML Title.’
- Click ‘Add Search Page’ again.
- Go to ‘Setup Search Page.’
- Select ‘All Content.’
- Click ‘Create Page.’

Integration of Smart Snippet Model in Hosted Search Page

To add Coveo’s Smart Snippet feature to your search interface, simply include the following HTML code to the hosted search page and then save and test it:

CoveoSmartSnippet: Displays the main answer snippet.
CoveoSmartSnippetSuggestions: Shows additional related suggestions.

Results

After integrating the Smart Snippet Model into the search page, users will directly see relevant, concise snippets in the search results. These snippets highlight key information that matches their query.

To see the query-based snippets, Enter any search term in the search interface to view the snippets based on that term.

For Example:

search term: Customizing Search Results Ranking and Ranking Functions

Here, you also see the SnippetSuggestions, also called “People also ask.”

Inspect the current page and check the Network tab to view the smart snippet object. Look for the ‘questionAnswer‘ object under the Preview tab. You can also see the similarity score assigned by the model to the displayed snippets by checking the score value.

Conclusion

Coveo’s Smart Snippets provide a robust solution for delivering precise, contextually relevant information directly within the search results, significantly enhancing user experience. This blog demonstrated how to take this functionality to the next level by integrating custom context into the Coveo Smart Snippet Model, tailoring the snippets even further to meet specific query intents. This improves the relevance of the information and streamlines the decision-making process for users.

Enhancing Coveo Search Experience: Enabling Partial Match and Query Syntax Toggles

Ashwini Bhave — Wed, 04 Dec 2024 12:21:04 +0000

The Coveo platform provides a powerful, customizable search experience. However, making advanced features like Partial Match and Query Syntax user-friendly can significantly improve users’ interactions with your search interface. This blog focuses on how to implement these toggles and integrate them seamlessly with the Coveo Query Pipeline.

Why Partial Match and Query Syntax?

Partial Match: This Coveo query parameter ensures results include documents that match a subset of the user’s query terms. It’s particularly useful for long-tail searches or cases where exact matches are unlikely.
Query Syntax: This feature enables advanced search operators (e.g., AND, OR) in the user’s query, giving power users better control over their search results.

Adding checkboxes for these features lets users toggle them on or off dynamically, tailoring the search experience to their preferences.

Implementation Overview

Step 1: Add Toggles to the UI

We introduced two simple checkboxes to toggle Partial Match and Query Syntax in real time. Here’s the HTML structure:




Partial Match



Query Syntax

.container {
display: flex;
gap: 10px;
}

.checkbox-label {
font-family: Arial, sans-serif;
font-size: 14px;
font-weight: bold;
display: flex;
align-items: center;
gap: 5px;
}

.checkbox-label input[type="checkbox"] {
width: 16px;
height: 16px;
cursor: pointer;
}

Step 2: Implement Toggle Logic

Use JavaScript to dynamically update the query context and trigger changes. The toggles were made functional by leveraging the Coveo Search API and the buildingQuery event, allowing real-time updates to the query context based on the states of the checkboxes.

// Root element for Coveo search interface
const root = document.querySelector("#search");

/** 
* Toggles the Partial Match context parameter based on the checkbox state. 
*/

function togglePartialMatch() {
    const partialMatchCheckbox = document.querySelector("#partialMatchCheckbox");
    if (partialMatchCheckbox) {
        const isActive = partialMatchCheckbox.checked;
        if (isActive) {
            console.log("Partial Match Enabled");
            // Listen to the buildingQuery event and update the query context
            Coveo.$$(root).on("buildingQuery", (e, args) => {
                args.queryBuilder.addContext({
                    partialMatch: isActive
                });
            });
        } else {
            console.log("Partial Match Disabled");
            Coveo.$$(root).on("buildingQuery", (e, args) => {
                args.queryBuilder.addContext({
                    partialMatch: isActive
                });
            });
        }
    } else {
        console.error("Partial Match Checkbox not found!");
    }
}

/**
* Toggles the Query Syntax context parameter based on the checkbox state. 
*/

function toggleQuerySyntax() {
    const querySyntaxCheckbox = document.querySelector("#querySyntaxCheckbox");
    if (querySyntaxCheckbox) {
        const isActive = querySyntaxCheckbox.checked;
        if (isActive) {
            console.log("Query Syntax Enabled");
            Coveo.$$(root).on("buildingQuery", (e, args) => {
                args.queryBuilder.addContext({
                    enableQuerySyntax: isActive
                });
            });
        } else {
            console.log("Query Syntax Disabled");
            Coveo.$$(root).on("buildingQuery", (e, args) => {
                args.queryBuilder.addContext({
                    enableQuerySyntax: isActive
                });
            });
        }
    } else {
        console.error("Query Syntax Checkbox not found!");
    }
}

Step 3: Configure Query Pipeline Rules

In the Coveo Admin Console, modify your query pipeline to respond to the context values sent from the front end.

Partial Match Configuration

Query Parameter: partialMatch

Override Value: true
Condition: Context[partialMatch] is true

Additional Overrides:

partialMatchKeywords: Set to 3
partialMatchThreshold: Set to 35%

Query Syntax Configuration

Query Parameter: enableQuerySyntax

Override Value: true
Condition: Context[enableQuerySyntax] is true.

Step 4: Detailed Flow for Context Parameters

User Interaction: When a user checks the Partial Match or Query Syntax toggle, the respective JavaScript function (togglePartialMatch or toggleQuerySyntax) is triggered.
Frontend Logic: The buildingQuery event dynamically updates the query context with parameters like partialMatch or enableQuerySyntax.
Example Context Update:
```
{
   "q": "example query",
   "context": {
     "partialMatch": true,
     "enableQuerySyntax": false
   }
}
```
Backend Processing: The query, along with the updated context, is sent to the Coveo backend. The Query Pipeline evaluates the context parameters and applies corresponding rules, like enabling partialMatch or enableQuerySyntax.
Dynamic Overrides: Based on the context values, overrides like partialMatchKeywords or partialMatchThreshold are applied dynamically.
Real-Time Results: Updated search results are displayed to the user without requiring a page reload.

Benefits of This Approach

Enhanced User Control: Allows users to tailor search results to their needs dynamically.
Real-Time Updates: Search settings are updated immediately, with no reloads.
Flexible Configuration: Query behavior can be adjusted via the Admin Console without modifying frontend code.
Scalable: Easily extendable for other toggles or advanced features.

The Results

With these toggles in place, users can:

Effortlessly switch between enabling and disabling Partial Match and Query Syntax.
Experience improved search results tailored to their input style.

Partial Match Results:

Query Syntax Results:

Conclusion

Leveraging Coveo’s context and query pipeline capabilities can help you deliver a highly interactive and dynamic search experience. Combining the UI toggles and backend processing empowers users to control their search experience and ensures that results align with their preferences.

Implement this feature today and take your Coveo search interface to the next level!

Useful Links

About custom context | Coveo Machine Learning

PipelineContext | Coveo JavaScript Search Framework – Reference Documentation

Taking advantage of the partial match feature | Coveo Platform

Query syntax | Coveo Platform

Integrating Real-World Data into Coveo Search Using the Generic REST API Source Connector

Ashwini Bhave — Tue, 03 Dec 2024 16:52:07 +0000

This blog will guide you through indexing content from API endpoints into Coveo using the Generic REST API source. This tool allows the indexing of data from any web service exposing a REST API, such as Content Management Systems (CMS), databases, or third-party platforms. While the demo API here is for illustration, the steps can be adapted for real-world scenarios, like integrating Adobe Experience Manager (AEM) data or fetching structured content, such as user profiles or metadata, from various repositories.

By the end of this guide, you’ll be able to index and display structured data in Coveo, enhancing search relevance and user experience.

Why Use Coveo’s Generic REST API Source?

The Generic REST API source in Coveo is designed to pull data from an API and make it available for search and analytics. It’s highly versatile and enables you to:

Index data from any API without a dedicated connector.
Customize indexing with JSON configurations for API calls and responses.
Access content from various web applications using REST APIs. And handle content from diverse repositories efficiently.
Simplifies data retrieval and management through structured API calls.

What You Need

API Access: The API should expose the data you want to index. For this blog, we’re using a sample API.
Coveo Admin Console Access: You’ll need admin rights to configure sources.
Optional Tool: Use Postman or a similar API client to inspect API responses before configuration.

Step-by-Step Implementation

Step 1: Explore the API Output

Before integrating with Coveo, examine the API response to understand the data structure. For this blog, I’m using Free fake and reliable API for testing and prototyping.

Test with Postman or cURL:

curl --location --request GET 'https://jsonplaceholder.typicode.com/users'

API Call:

GET https://jsonplaceholder.typicode.com/users

Accept: application/json
Authorization: Bearer **********-****-****-****-************

Sample API Response:

[
  {
    "id": 1,
    "name": "Leanne Graham",
    "username": "Bret",
    "email": "Sincere@april.biz",
    "address": {
      "street": "Kulas Light",
      "suite": "Apt. 556",
      "city": "Gwenborough",
      "zipcode": "92998-3874"
    },
    "phone": "1-770-736-8031 x56442",
    "website": "hildegard.org"
  }
]

JSON Configuration Structure

Before crawling data from the API, define a clear structure for the JSON configuration. This structure determines how Coveo retrieves and organizes data from the API.

API (Root Node): The interaction entry point, representing the external data source (any RESTful API).
Service: The layer that processes requests to the API and supports various data sources or services.
Endpoints: Defined paths the API exposes (e.g., /users, /comments, /albums).
Data Mapping: Each endpoint retrieves specific data (e.g., user profiles from /users, comments from /comments, albums from /albums).

Identify Fields for Indexing

From the response, fields like id, name, email, and address can be mapped for indexing.

Step 2: Create the Generic REST API Source Connector in coveo

Log In to Coveo Admin Console: Navigate to Content > Sources and click Add Source.
Select Source Type: Choose REST API from the options.
Configure Basic Details, Source Name: Use something descriptive like user profiles etc.
Don’t build it; just save it for now.

Note:

REST API URL: https://jsonplaceholder.typicode.com/users
Authentication: Skip if the API is public. If authentication is required, configure it under the Authentication Tab.

Step 3: Configure JSON Settings

After saving the source, click Edit JSON Configuration from the source menu.
Replace the default JSON with the following configuration:

{
  "services": [
    {
      "url": "https://jsonplaceholder.typicode.com",
      "paging": {
        "pageSize": 20,
        "offsetStart": 10,
        "offsetType": "item",
        "parameters": {
          "limit": "limit",
          "offset": "offset"
        }
      },
      "endpoints": [
        {
          "path": "/users",
          "method": "GET",
          "itemType": "userprofile",
          "uri": "%[coveo_url]/users/%[id]",
          "clickableUri": "%[coveo_url]/users/%[id]",
          "title": "%[name]",
          "metadata": {
            "id": "%[id]",
            "username": "%[username]",
            "email": "%[email]",
            "address": "%[address]",
            "phone": "%[phone]",
            "website": "%[website]",
            "company": "%[company]"
          }
        }
      ]
    }
  ]
}

Step 4: Save and Rebuild the Source

Click Save to apply changes.
Go back to the source page and click Save and Rebuild.
Monitor logs to ensure successful indexing using the log browser.

The screenshot below shows the rebuild process or logs confirming successful indexing

Mapping and Displaying Data

Step 5: Map API Fields to Coveo Fields and then associate it with the rest-api source

Navigate to Fields in the Admin Console.
As shown below, create new fields for attributes such as id, name, email, address, and others. The field for ‘name’ has already been created; follow the same process for the other fields.
Map these fields in the Mappings tab of the source configuration.

For more detailed information on Coveo fields and mappings, refer to the following blogs:

To view a more detailed field mapping configuration for your source, see the steps below: See the below Mapping JSON:

[
  {
    "content": "%[filename]",
    "extractionMethod": "METADATA",
    "fieldName": "filename",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-qaut7yluelbrwf5b3x23ea2iji",
    "kind": "COMMON",
    "rules": [
      "%[filename]"
    ]
  },
  {
    "content": "%[clickableuri]",
    "extractionMethod": "METADATA",
    "fieldName": "clickableuri",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-qidgh3yqtqgxpt2zarqg5y2fki",
    "kind": "COMMON",
    "rules": [
      "%[clickableuri]"
    ]
  },
  {
    "content": "%[email]",
    "extractionMethod": "METADATA",
    "fieldName": "up_email",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-q66t3o5osh6wqdzc4rlwrlsc3m",
    "kind": "COMMON",
    "rules": [
      "%[email]"
    ]
  },
  {
    "content": "%[phone]",
    "extractionMethod": "METADATA",
    "fieldName": "up_phone",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-qr7g25pyvh3rl42wtyheppcopy",
    "kind": "COMMON",
    "rules": [
      "%[phone]"
    ]
  },
  {
    "content": "%[username]",
    "extractionMethod": "METADATA",
    "fieldName": "up_username",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-sfqu5sxfgk32iarhiaes22chhm",
    "kind": "COMMON",
    "rules": [
      "%[username]"
    ]
  },
  {
    "content": "%[website]",
    "extractionMethod": "METADATA",
    "fieldName": "up_website",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-qrti6wae2lzbq4iy7vd5zhkatq",
    "kind": "COMMON",
    "rules": [
      "%[website]"
    ]
  },
  {
    "content": "%[company]",
    "extractionMethod": "METADATA",
    "fieldName": "up_company",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-sxfkfclwtarbh3fvrjvtfr2iwe",
    "kind": "COMMON",
    "rules": [
      "%[company]"
    ]
  },
  {
    "content": "%[address]",
    "extractionMethod": "METADATA",
    "fieldName": "up_address",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-u6ajgmpuoedwigbmeuzhszkpvy",
    "kind": "COMMON",
    "rules": [
      "%[address]"
    ]
  },
  {
    "content": "%[id]",
    "extractionMethod": "METADATA",
    "fieldName": "up_id",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-udpex4lvcj5g7jaynzkwsc2fie",
    "kind": "COMMON",
    "rules": [
      "%[id]"
    ]
  },
  {
    "content": "%[month]",
    "extractionMethod": "METADATA",
    "fieldName": "month",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-qrz336tyq4qbvj2qizlqpwkaky",
    "kind": "COMMON",
    "rules": [
      "%[month]"
    ]
  },
  {
    "content": "%[title:crawler]",
    "extractionMethod": "METADATA",
    "fieldName": "title",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-r3agbznnaduqkgul7b7hudsarq",
    "kind": "COMMON",
    "rules": [
      "%[title:crawler]"
    ]
  },
  {
    "content": "%[year]",
    "extractionMethod": "METADATA",
    "fieldName": "year",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-rbfbf2soa6rzlgai7eygpfkgoq",
    "kind": "COMMON",
    "rules": [
      "%[year]"
    ]
  },
  {
    "content": "%[mobile]",
    "extractionMethod": "METADATA",
    "fieldName": "mobilephone",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-rdhx4wtyfy5znb6txno4qvcpba",
    "kind": "COMMON",
    "rules": [
      "%[mobile]"
    ]
  },
  {
    "content": "%[company]",
    "extractionMethod": "METADATA",
    "fieldName": "company",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-rdjy3kkqcxbs66phsdmcfdcpou",
    "kind": "COMMON",
    "rules": [
      "%[company]"
    ]
  },
  {
    "content": "%[permanentid]",
    "extractionMethod": "METADATA",
    "fieldName": "permanentid",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-rirzsjru43xswhpfwc4c7bkb4m",
    "kind": "COMMON",
    "rules": [
      "%[permanentid]"
    ]
  },
  {
    "content": "%[coveo_externalurl]",
    "extractionMethod": "METADATA",
    "fieldName": "relatedlink",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-rjuqiqtvi6fe5kbrwwvbc2sanu",
    "kind": "COMMON",
    "rules": [
      "%[coveo_externalurl]"
    ]
  },
  {
    "content": "%[office]",
    "extractionMethod": "METADATA",
    "fieldName": "office",
    "id": "ashwinitestorg6zfn7o3t-wktezkeyf53ibe2gryghnjsk6y-xsbc254qtlebiqu4dcqt6rcmn4",
    "kind": "COMMON",
    "rules": [
      "%[office]"
    ]
  }
]

To view the indexed documents with their mapped properties, go to Content > Content Browser in the Coveo Admin Console.

Click the properties option in the top-right corner to view metadata, as shown below.

Here are the properties, as shown below

Step 6: Configure Search Interface

Display the indexed data on the Coveo search page. Use Coveo JSUI Framework components to show the details:

Search interface displaying the mapped fields.

Conclusion

Indexing data from APIs like AEM into Coveo using the Generic REST API source is straightforward. Following this guide, you can set up a robust pipeline to fetch, map, and display API data in your Coveo search interface. With the flexibility of JSON configurations and Coveo’s search components, it can deliver powerful, enriched search experiences.

Useful Links

Add a REST API source | Coveo Platform

Use the Log Browser to review indexing logs | Coveo Platform

Inspect items with the Content Browser | Coveo Platform

Part 1: Building the Source and Corresponding Mappings in Coveo Enterprise Search / Blogs / Perficient

Part 2: Building the Source and Corresponding Mappings in Coveo Enterprise Search / Blogs / Perficient

Lessons from the Front: Indexing Content Hub in Coveo

Nick Sturdivant — Wed, 29 May 2024 16:56:52 +0000

Intro

In the new composable world, it’s common for medium to large Sitecore solutions to include a search appliance like Coveo and a digital asset management tool like Sitecore Content Hub. A typical use-case is to build search sources in Coveo that index content residing in Content Hub. Those indexes, in turn, can then be used to build front-end search experiences. In this blog post, I’d like to cover a few tips for working with the Content Hub REST API to populate search sources in Coveo. These tips are based on my experiences on a recent project that used the Content Hub REST API to index PDF documents in Coveo.

#1 – Knowing Which API to Use

Having not previously used the Content Hub REST API, I wasn’t initially aware that there are several endpoints. Here’s a quick rundown of a few of them:

Query API (GET http:///api/entities/query/)

The Querying feature allows you to query for specific entities using specific indexed metadata fields. This basic querying is contrasted against the more elaborate search functionality offered by the M.Content API.

Scroll API (GET http:///api/entities/scroll/)

You can use Scroll API to retrieve a large number of results (or even all results) from a single query.

It does not support the skip parameter and only lets you request the next page through the resource. You can continue paging until it no longer returns results or you have reached the last page.

SearchAfter API (POST http:///api/entities/searchafter/)

The SearchAfter API is used to fetch multiple pages of search results sequentially. To start, a request is made for the first page of results, which includes a last_hit_data value corresponding to the last item in the page. This value is then used to fetch subsequent pages until all results are retrieved.

On this particular project, the Query API was used to pull PDFs. By design, the Query API returns a maximum of 10k results. In this case, that was okay–there were something like ~9k assets in Content Hub at the time (without any additional filtering applied). However, in order to future-proof the query a little and to avoid unnecessary processing of non-PDF documents, it made sense to make the query more specific (see #2, below ).

Net out: If you know you’ll need to pull 10k+ items from Content Hub and efficiently paginate through all of them, use the SearchAfter API. If your number of assets is smaller than 10k, then the Query API is probably fine. Note that the SearchAfter API will soon deprecate and replace the Scroll API so it’s best to avoid the Scroll API for any new work.

#2 – Filtering on Media Type and Approval Status

I like to think that I can figure most things out if I read the documentation. However, when it came to updating the query to filter down to approved PDFs for indexing, it wasn’t at all clear to me how to do that. As mentioned above, the Query API is limited to 10k results and we were pretty close to that in terms of total asset count. It was important to be more selective when pulling assets such that only approved PDFs were returned.

After unsuccessfully experimenting for while, I broke down and opened a Sitecore support ticket to ask how that could be accomplished. I got an answer…and it worked, but it wasn’t as obvious as I would have liked it to be. Who likes magic numbers?

To query for PDF assets: ... AND Parent('AssetMediaToAsset').id==1057.

To ensure that only approved assets are included: ... AND Parent('FinalLifeCycleStatusToAsset')==544.

Putting it together, the full query URL (without any ordering applied; see #3 below ) was:

{baseURL}/api/entities/query?query=Definition.Name=='M.Asset' AND Parent('AssetMediaToAsset').id==1057 AND Parent('FinalLifeCycleStatusToAsset').id==544

In other words:

Give me all assets whose file type is PDF and whose approval status is approved.

Now, I think these IDs are common across all Content Hub instances but, just in case, please make sure they match the appropriate values in your Content Hub instance prior to using the same IDs in your queries. You can find the asset media type IDs under Taxonomy Management in Content Hub:

Asset media types in Content Hub’s Taxonomy Management interface.

#3 – Sorting

When you’re building a REST API source in Coveo with the intention of iterating through hundreds or thousands of assets in Content Hub, it’s best to return them in a consistent order. At one point during the troubleshooting of some indexing issues, Coveo support suggested that the Content Hub API was returning results in an inconsistent order and that that was potentially a contributing factor. While that was never conclusively shown to be the case, it does make sense to apply a sort, even if only to ensure assets are processed in a specific, predictable order.

The query was updated to sort on createdOn ascending (oldest first); the updated query URL looked like this:

{baseURL}/api/entities/query?query=Definition.Name=='M.Asset' AND Parent('AssetMediaToAsset').id==1057 AND Parent('FinalLifeCycleStatusToAsset').id==544&sort=createdOn&order=Asc

Interestingly enough, I found that created_on worked, too, but, according to Sitecore support, createdOn should be used instead.

#4 – Paging

REST API sources in Coveo will almost always be configured to paginate through the results coming from the external API, otherwise only the first page’s worth of data will be processed and indexed. It’s important to ensure paging is configured correctly to allow for reasonable index rebuild and rescan times, too. In this case, using the Query API, and with a page size of 25 items per page, the paging configuration section in the Coveo REST API source looked like this:

...
"paging": {
  "pageSize": 25,
  "offsetType": "url",
  "nextPageKey": "next.href",
  "parameters": {
    "limit": "take"
  },
  "totalCountKey": "total_items"
},
...

The corresponding paging properties as returned in the Query API response (for the first page) looked like this:

{
  "items": [ ... ],
  "total_items": 12345,
  "returned_items": 25,
  "next": {
    "href": "https://{baseURL}/api/entities/query?skip=25&take=25&query=Definition.Name%3D%3D%27M.Asset%27%20AND%20Parent(%27AssetMediaToAsset%27).id%3D%3D1057%20AND%20Parent(%27FinalLifeCycleStatusToAsset%27).id%3D%3D%20544&sort=createdOn&order=Asc",
    ...
  },
  ...
}

Note that the paging configuration may need to change if you’re using a different Content Hub API endpoint. For more information about configuring paging in Coveo REST API sources, refer to the official documentation.

#5 – File Size Can Affect Document Properties in Extensions

In Coveo, the maximum size for a single item is approximately 256 MB (reference). That number includes the item’s permissions, metadata, and content. For larger files, the content isn’t indexed, just the metadata. This limit came to light indirectly on this recent project.

While outside the scope of this post, Coveo supports extensions that can be attached to search sources. Extensions are bits of Python code that Coveo will run in the context of each document while processing the source. On this project, an extension was used to do things like conditionally reject (skip indexing) documents, set metadata fields based on other properties, etc. At one point, the extension attempted to resolve the extension (file type) for the document using the following code:

filetype = document.get_meta_data_value("detectedfiletype")[0]

For any documents not above the maximum size, the filetype variable would have the expected value: "pdf". For any documents that were above the maximum size, the variable had a generic value that, while non-empty, was also not the expected file type. Because the document was too large, the document object available within the extension didn’t have the expected values, including detectedfiletype. As a result, because the file was large, some logic within the extension broke as this case wasn’t accounted for.

Upon further investigation of the PDFs in Content Hub, it was noted that, of the 10 or so that consistently exhibited indexing issues, all of them were 300+ MB in size.

For more information on indexing pipeline extensions (IPE), please see Indexing pipeline extension overview.

Net out: If you’re using an extension on a source and you’re noticing that the document object has one or more properties that aren’t returning what you’d expect to see, double-check to ensure that the underlying document isn’t > 256 MB and that you aren’t trying to access properties within the extension that will never correctly resolve.

Thanks for the read!

Coveo Recognizes Perficient Colleagues as MVPs in 2024

Gracey Allison — Thu, 14 Mar 2024 19:24:09 +0000

Perficient Receives Seven “Most Valuable Professional” Recognitions

We are proud to share our inclusion in the Coveo MVP Program with 7 of our own selected for the recognition. The Coveo MVP program recognizes individuals for their invaluable contributions and expertise within the Coveo ecosystem.

To be considered for the recognition of Coveo MVP, one must possess a deep understanding of the platform and its business value to demonstrate strong thought leadership in the community. In addition, individuals must deploy quality implementations that enhance adoption and boast long-term success for customers using Coveo.

Join us in congratulating our MVPs:

Eric Immerman, Director
Kristofer Quinn, Senior Technical Architect
Ryan Weeber, Lead Technical Consultant
Rohit Patidar, Lead Technical Consultant
Fernando Rodriguez Rojas, Lead Technical Consultant
William Kirkconnell, Technical Consultant
Zachary Fischer, Senior Solutions Architect

First time MVP recipient and Lead Technical Consultant, Ryan Weeber bolsters excitement on his inclusion:

“I am thrilled to be recognized for the first time as a Coveo MVP! It’s such an honor to be included among this incredibly talented group of professionals.”

Eric Immerman, Coveo practice director celebrates his 4th consecutive inclusion in the Coveo MVP program and reflects on his team’s success:

“Being recognized once more as a Coveo MVP remains a fantastic acknowledgment of the expertise and hard work my team and I contribute towards ensuring our clients fully benefit from and use the Coveo platform effectively.”

Coveo at Perficient

Our Coveo practice helps brands design, architect and implement modern intelligent search solutions that empower users to be more successful in delivering a winning customer experience. As a Platinum partner and two time Accelerator Award recipient, we pride ourselves on providing unique, innovative solutions to our clients.

We would like to extend a special thanks to our team and their continued dedication to demonstrating key thought leadership and technical expertise to grow the Perficient + Coveo partnership. To learn more about Perficient’s Coveo solutions, visit our Coveo partner page, subscribe to Perficient’s blog and follow us on LinkedIn and Twitter.

Perficient Wins 2023-24 Coveo Relevance Accelerator Award

Susan Welton — Thu, 25 Jan 2024 23:19:18 +0000

Perficient is excited to announce we’ve won Coveo’s exclusive partner award! The Accelerator Award commemorates a Coveo partner that exhibited deep knowledge and technical expertise, understands a customers’ business challenges, and clearly delivers value-driven business outcomes.

Perficient is a trusted Coveo Platinum Partner with expertise in modern intelligent search solutions. Our award-winning work helps organizations provide their customers and employees with relevant search results and recommendations while increasing revenue, boosting conversion rates, and improving employee efficiency.

This award marks the second time Perficient has received a Coveo partner award. These awards are a testament to the incredible work our teams deliver using the Coveo platform to accelerate outcomes for our clients. Huge shoutout to Perficient’s own Eric Immermann, Director Enterprise Search, and Kyla Faust, Alliance Manager, for their investment in the partnership, as well as the extended team for all their continuous collaboration in making our joint customers successful.

“We’re honored to be recognized by Coveo for the delivery of value-driven business outcomes,” said Eric Immermann. “Coveo serves as a powerful platform as customers demand more personalized and conversational experiences. In partnering with them, Perficient can deploy the latest advancements in AI and search to our clients.”

Our cross-technology and platform expertise enables us to seamlessly integrate intelligent search with a variety of enterprise applications to unlock the value of information and transform your business. We leverage the best features across industry-leading platforms to provide innovative solutions and drive outcomes that meet the unique needs of each client. With Coveo, you can expect to see tangible results such as higher productivity, improved customer satisfaction, and increased revenue.