/* Global styles */

#topbar-cta-button {
  margin-left: 1rem;
}

#topbar-cta-button a {
  display: flex;
  align-items: center;
  padding: 0.375rem 1rem !important;
  gap: 0.5rem;
  background-color: #1C17FF;
  color: #fff !important;
  border-radius: 0.25rem;
  font-weight: 500;
  letter-spacing: 0.4px;
}

#topbar-cta-button a:hover {
  background-color: #030080 !important;
}


/* #topbar-cta-button span {
  border-radius: 4px;
  font-weight: 500;
  letter-spacing: 0.4px;
} */

/* #topbar-cta-button div > svg {
  display: none;
} */

/* inserting svg via :after isn't working for some reason, used js instead */
/* #topbar-cta-button div::after {
  content: url('data:image/svg+xml;utf8,<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="Icon Right"><path id="Vector" d="M8.08906 5L6.91406 6.175L10.7307 10L6.91406 13.825L8.08906 15L13.0891 10L8.08906 5Z" fill="white"/></g></svg>');
  content: "test";
  display: block;
  width: 20px;
  height: 20px;
  margin-left: 8px;
  background-image: url('data:image/svg+xml;utf8,<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="Icon Right"><path id="Vector" d="M8.08906 5L6.91406 6.175L10.7307 10L6.91406 13.825L8.08906 15L13.0891 10L8.08906 5Z" fill="white"/></g></svg>');
  background-color: #000000;
  background-size: contain;
  background-repeat: no-repeat;
  background-position: center;
} */


.documentation-link {
  color: #1c17ff;
  text-decoration: none;
}

.documentation-link:hover {
  color: #000000; /* Black color when hovering */
}

.custom-button {
  display: inline-block;
  padding: 2px 8px;
  background-color: #f1f1f1;
  color: #333; /* Text color */
  border: 1px solid #aaa; /* Border color */
  border-radius: 25px; /* Rounded borders */
  text-align: center;
  user-select: none;
  transition: background-color 0.3s ease; /* Smooth transition for background color */
}

/* Change the button color on hover (make it unclickable) */
.custom-button:hover {
  background-color: #1c17ff;
  color: #f1f1f1;
}

/* Adjust the width for the second column */
/* td:nth-child(2) {
  width: 200px; /* Adjust the width as per your requirement
} */

/* 
Add an announcement bar 
TODO: This can be version specific if you add a page-specific class/ID, but it doesn't seem to work for the OpenAI docs without rewriting the JSON
*/
/*  #navbar:before {
  background-color: #ff4c04;
  content: "The legacy version of the API, which required regional URLs for control plane operations, is deprecated as of April 15, 2024 and will be removed in a future, to be announced, release.";
  color: rgb(255, 255, 255);
  display: block;
  text-align: center;
  padding: 6px;
  font-size: 90%;
}
*/
/* Text color */
/* body {
  color: #121142 !important;
} */

/* Header */
#navbar {
  background: white;
  border-bottom: 1px solid #e2e5e7;
  /* position: sticky !important; */
  /* top: 0 !important; */
}
/* Top nav container */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type {
  justify-content: space-between;
  max-height: 46px; 
}

#navbar .max-w-8xl {
  max-width: 100%;
}

/* Logo + "Docs" text + version select */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:first-of-type {
  flex: initial;
}

#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:first-of-type > a:first-of-type {
  flex: initial;
  display: flex;
}

#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:first-of-type > a:first-of-type > img {
  max-width: 97.143px;
  max-height: 20px;
}

#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:first-of-type > a:first-of-type::after {
  content: "Docs";
  margin-left: 6px;
  color: #121142;
  color: var(--Light-Text-Primary, #121142);
  font-size: 16.5px;
  font-style: normal;
  font-weight: 500;
  line-height: 158%; /* 24.75px */
  letter-spacing: 0.15px;
  vertical-align: text-top;
}


/* Version select */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:first-of-type button {
  border-radius: 0.25rem;
  border: 1px solid rgba(115, 143, 171, 0.50);
  background-color: transparent !important;
  color: #121142;
  margin-left: 11px;
}


/* Right side nav container */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:nth-of-type(3) {
  flex: initial;
  margin-left: 0;
}

/* Prevent nav items from shrinking */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:nth-of-type(3) > nav {
  flex-shrink: 0;
}

/* nav links */
#navbar nav a {
  color: #121142;
  padding: 0.6rem 1rem;
  transition: background-color 250ms cubic-bezier(0.4, 0, 0.2, 1);
}

#navbar nav a:hover {
  background-color: rgba(27, 23, 245, 0.04);
  border-radius: 0.25rem;
}

#navbar nav ul li:not(:last-of-type) {
  margin-left: 0;
}

/* Hide dark mode toggle */
#navbar > div:first-of-type > div:first-of-type > div:first-of-type > div:nth-of-type(3) > div {
  display: none;
}

/* Second nav container */
/* Links */
#navbar > div:nth-of-type(2) > a {
  color: #121142;
  margin: 0;
  padding-left: 0.875rem;
  padding-right: 0.875rem;
}

/* Selected links */
#navbar > div:nth-of-type(2) > a.font-semibold {
  color: #1B17F5;
  border-bottom-width: 0.1875rem;
  border-color: #1B17F5;
}

/* Sidebar */
#sidebar {
  left: 0rem;
  padding-left: 3rem;
  background: white;
  border-right: 1px solid #e2e5e7;
  /* position: sticky; */
  /* flex-shrink: 0; */
  /* top: 0; */
}
/* Sidebar headings and link color */
#sidebar h5, #sidebar a {
  color: #121142;
}

/* Sidebar Introduction link */
#sidebar > div > ul > div:first-of-type > li:only-of-type {
  margin-left: 0;
}
#sidebar > div > ul > div:first-of-type > li:only-of-type > a {
  font-weight: 600;
}

/* Sidebar children */
#sidebar > div > ul > div > li {
  margin-left: 0.75rem;
}

/* Selected sidebar children */
#sidebar > div > ul > div > li > a.font-semibold {
  color: #1B17F5;
  font-weight: 400;
}

/* Main content area */
/* main > div:first-of-type > div:last-of-type > div:first-of-type {
  display: flex;
} */

/* Content container */
/* #content-container {
  padding-left: 3.5rem !important;
}
#content-container > div {
  padding-top: 1rem !important;
} */

@media (min-width: 1024px) {
  #content-container {
    padding-left: 19.125rem;
  }

  #content-container > div {
    gap: 3rem;
    padding-top: 10.5rem;
  }

  #content-container #table-of-contents {
    padding-left: 0;
  }
}



/* Fix horizontal scrollbar issue */
main > div:first-of-type {
  overflow: hidden;
}

/* Title eyebrow */
#header .eyebrow {
  text-transform: uppercase;
  color: #121142;
  font-size: 0.625rem;
  letter-spacing: 1px;
  line-height: 160%;
}

/* Hide empty eyebrow */
#header .eyebrow:empty  {
  display: none;
}

/* Title container */
#header > div:first-of-type > div:nth-of-type(2) {
  margin-top: 0;
}

/* Title */
#header h1 {
  color: #121142;
}

/* Article text */
.prose h2, .prose h3, .prose h4, .prose p {
  color: #121142;
}

.prose a {
  color: #1B17F5;
  font-weight: 400;
}

/* Overwrite tailwind max-width */
.max-w-8xl {
  max-width: 94.5rem;
}

.card {
  box-shadow: none;
  border: 1px solid #D8DDDF;
  border-radius: 0.25rem;
  transition: box-shadow 0.3s ease;
}

.card:hover {
  box-shadow: 0px 5px 5px -3px rgba(163, 169, 175, 0.20), 0px 8px 10px 1px rgba(163, 169, 175, 0.14), 0px 3px 14px 2px rgba(163, 169, 175, 0.12);
  border: 1px solid #D8DDDF !important;
}

.card > div {
  padding: 1.5rem;
}

.card h2 {
  font-size: 1.25rem;
}

.card p {
  margin-top: 0.625rem;
  font-size: 0.875rem;
  color: #121142;
}

.card .eyebrow {
  font-size: 0.625rem;
  text-transform: uppercase;
  line-height: 160%;
  letter-spacing: 1px;
}

.card .integration-logo {
  width: 3.125rem;
  height: 3.125rem;
  display: flex;
  justify-content: center;
  align-items: center;
}

/* Integrations */
#integrations-banner {
  position: relative;
  margin-top: 7.25rem;
  height: 12.5rem;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  overflow: hidden;
  background: url('https://mintlify.s3-us-west-1.amazonaws.com/pinecone-2/images/background.png') no-repeat center center;
  background-size: 90%;
  background-color: #1F1F33;
  text-align: center;
}

#integrations-banner h1{
  color: #FFFFFF;
  font-size: 3rem;
}

#integrations-banner p {
  color: #FFFFFF;
  font-size: 1.25rem;
  opacity: 0.7;
  margin-top: 0.5rem;
}

/* Integrations related articles */
#related-articles {
  display: flex;
  flex-direction: column;
  width: 100%;
}

#related-articles h2 {
  color: #121142;
  font-size: 1.25rem;
  font-weight: 600;
  letter-spacing: 0.15px;
  line-height: 150%;
  margin-bottom: 1rem;
}

#related-articles a {
  padding: 1.0625rem 0;
  display: flex;
  align-items: flex-start;
  justify-content: space-between;
  gap: 1rem;
  color: #121142;
  font-size: 0.875rem;
  line-height: 150%;
  letter-spacing: 0.15px;
}

#related-articles a:not(:last-of-type) {
  border-bottom: 1px solid #D8DDDF;
}

#related-articles a:hover {
  opacity: 0.7;
}

#related-articles a > svg {
  flex-shrink: 0;
}

/* Integrations back button */
#back-button {
  display: flex;
  gap: 0.5rem;
  align-items: center;
  color: #121142 !important;
  font-size: 0.875rem;
  line-height: 150%;
  letter-spacing: 0.15px;
  margin-bottom: 1.5rem;
}

#back-button:hover {
  opacity: 0.7;
}

#back-button > svg {
  flex-shrink: 0;
}

"use client";

window.onload = function () {
  localStorage.setItem("isDarkMode", "false");
};

// Get the Mintlify search containers, going to reuse them as the triggers for Inkeep
const searchButtonContainerIds = [
  "search-bar-entry",
  "search-bar-entry-mobile",
];

// Clone and replace, needed to remove existing event listeners
const clonedSearchButtonContainers = searchButtonContainerIds.map((id) => {
  const originalElement = document.getElementById(id);
  const clonedElement = originalElement.cloneNode(true);

  originalElement.parentNode.replaceChild(clonedElement, originalElement);

  return clonedElement;
});

// Load the Inkeep script
const inkeepScript = document.createElement("script");
inkeepScript.type = "module";
inkeepScript.src =
  "https://unpkg.com/@inkeep/widgets-embed@0.2.271/dist/embed.js";
document.body.appendChild(inkeepScript);

// Once the Inkeep script has loaded, load the Inkeep chat components
inkeepScript.addEventListener("load", function () {
  // Customization settings
  const sharedConfig = {
    stylesheetUrls: [
      "https://www.pinecone.io/customerStylesheets/pinecone.css",
    ],
    baseSettings: {
      apiKey: "ac936dc250fee335d56e8e7f01c93f6352fa88a69331053c",
      integrationId: "clu1mcp8l0008nc70ugr3yft8",
      organizationId: "org_2w8WbI2ZUZ7xN2wp",
      primaryBrandColor: "#1c17ff",

      theme: {
        primaryColors: {
          textColorOnPrimary: "white",
        },
        colors: {
          gray: {
            "gray.50": "242 243 251",
            "gray.100": "236 237 246",
            "gray.200": "223 225 236",
            "gray.300": "203 207 220",
            "gray.400": "152 159 177",
            "gray.500": "105 111 132",
            "gray.600": "74 83 104",
            "gray.700": "54 64 86",
            "gray.800": "31 40 61",
            "gray.900": "17 24 46",
          },
        },
        components: {
          SearchBarTrigger: {
            defaultProps: {
              variant: "subtle",
            },
          },
        },
      },
      customIcons: {
        search: { builtIn: "IoSearch" },
      },

      breadcrumbRules: {
        urlToBreadcrumbMapper: [
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "pinecone.io",
            },
            replaceLeading: true,
            breadcrumbName: "Home",
          },
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "docs.pinecone.io",
            },
            replaceLeading: true,
            breadcrumbName: "Docs",
          },
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "www.pinecone.io/learn",
            },
            replaceLeading: true,
            breadcrumbName: "Learn",
          },
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "www.pinecone.io/blog",
            },
            replaceLeading: true,
            breadcrumbName: "Blog",
          },
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "pinecone.io/community",
            },
            replaceLeading: true,
            breadcrumbName: "Community",
          },
          {
            matchingRule: {
              ruleType: "PartialUrl",
              partialUrl: "https://support.pinecone.io/hc/en-us",
            },
            replaceLeading: true,
            breadcrumbName: "Support",
          },
        ],
      },

      customCardSettings: [
        {
          filters: {
            RootBreadcrumb: "Community",
          },
          searchTabLabel: "Community",
          icon: { builtIn: "IoPeopleOutline" },
        },
        {
          filters: {
            RootBreadcrumb: "Blog",
          },
          searchTabLabel: "Blog",
          icon: { builtIn: "IoPencilOutline" },
        },
        {
          filters: {
            RootBreadcrumb: "Learn",
          },
          searchTabLabel: "Learn",
          icon: { builtIn: "IoBookOutline" },
        },
        {
          filters: {
            RootBreadcrumb: "Home",
          },
          searchTabLabel: "Home",
          icon: { builtIn: "IoHomeOutline" },
        },
        {
          filters: {
            RootBreadcrumb: "Support",
          },
          searchTabLabel: "Support",
          icon: { builtIn: "IoHelpBuoyOutline" },
        },
      ],
    },
    aiChatSettings: {
      chatSubjectName: "Pinecone",
      botAvatarSrcUrl:
        "https://storage.googleapis.com/organization-image-assets/pinecone-botAvatarSrcUrl-1707422859519.svg",
      botAvatarDarkSrcUrl:
        "https://storage.googleapis.com/organization-image-assets/pinecone-botAvatarDarkSrcUrl-1707422858768.svg",
      getHelpCallToActions: [
        {
          name: "Community",
          url: "https://community.pinecone.io/",
          icon: {
            builtIn: "IoPeopleOutline",
          },
        },
        {
          name: "Support Center",
          url: "https://support.pinecone.io/",
          icon: {
            builtIn: "IoHelpBuoyOutline",
          },
        },
      ],
      quickQuestions: [
        "What are the benefits of serverless?",
        "How do I do a dense and sparse search?",
        "What are the primary ways to minimize latency?",
      ],
    },
    searchSettings: {
      tabSettings: {
        isAllTabEnabled: false,
        rootBreadcrumbsToUseAsTabs: [
          "Docs",
          "Learn",
          "Forums",
          "Community",
          "Support",
          "Blog",
          "Home",
        ],
      },
    },
  };

  // for syncing with dark mode
  const colorModeSettings = {
    observedElement: document.documentElement,
    isDarkModeCallback: (el) => {
      return el.classList.contains("dark");
    },
    colorModeAttribute: "class",
  };

  // instantiate Inkeep "custom trigger" component
  const inkeepSearchModal = Inkeep({
    ...sharedConfig.baseSettings,
  }).embed({
    componentType: "CustomTrigger",
    colorModeSync: colorModeSettings,
    properties: {
      ...sharedConfig,
      isOpen: false,
      onClose: () => {
        inkeepSearchModal.render({
          isOpen: false,
        });
      },
    },
  });

  // When the Mintlify search bar clone is clicked, open the Inkeep search modal
  clonedSearchButtonContainers.forEach((trigger) => {
    trigger.addEventListener("click", function () {
      inkeepSearchModal.render({
        isOpen: true,
      });
    });
  });

  // Add event listener for the 'keydown' event on the document object for cmd + k
  document.addEventListener("keydown", function (event) {
    if (event.metaKey && event.key === "k") {
      event.preventDefault(); // Prevent the default behavior of the keyboard shortcut
      inkeepSearchModal.render({
        isOpen: true,
      });
    }
  });
});

// window.addEventListener("load", function () {
//   if (window.location.pathname === "/integrations/overview") {
//     // const banner = document.createElement('div');
//     // banner.id = 'integrations-banner';
//     // banner.style.background = 'yellow';

//     // const navbar = document.getElementById('navbar');

//     // navbar.insertAdjacentElement('afterend', banner);

//     const toc = document.querySelector("#table-of-contents");
//     toc.style.display = "none";

//     const header = document.querySelector("#header");
//     header.style.display = "none";
//   }
// });

function addRelatedArticles(titles, links) {
  const existing = document.querySelector("#related-articles");
  if (existing) return;

  const sidebar = document.querySelector("#table-of-contents");
  const relatedArticles = document.createElement("div");
  relatedArticles.id = "related-articles";

  const title = document.createElement("h2");
  title.textContent = "Related Articles";
  relatedArticles.appendChild(title);

  titles.forEach((title, index) => {
    const relatedArticle = document.createElement("a");
    relatedArticle.href = links[index];
    relatedArticle.textContent = title;
    relatedArticle.insertAdjacentHTML(
      "beforeend",
      '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="ChevronRightFilled"><path id="Vector" d="M9.70492 6L8.29492 7.41L12.8749 12L8.29492 16.59L9.70492 18L15.7049 12L9.70492 6Z" fill="#1B17F5"/></g></svg>'
    );
    relatedArticles.appendChild(relatedArticle);
  });

  sidebar.appendChild(relatedArticles);
}

const relatedArticles = {
  airbyte: {
    titles: [
      "Data Sync and Search: Pinecone and Airbyte",
      "Introduction to Airbyte and the Pinecone connector",
      "Postgres to Pinecone Syncing",
    ],
    links: [
      "https://www.pinecone.io/learn/series/airbyte/",
      "https://www.pinecone.io/learn/series/airbyte/airbyte-and-pinecone-intro/",
      "https://www.pinecone.io/learn/series/airbyte/airbyte-postgres-to-pinecone/",
    ],
  },

  bedrock: {
    titles: ["Pinecone as a Knowledge Base for Amazon Bedrock"],
    links: ["https://www.pinecone.io/blog/amazon-bedrock-integration/"],
  },

  sagemaker: {
    titles: [
      "Mitigate hallucinations through Retrieval Augmented Generation using Pinecone vector database & Llama-2 from Amazon SageMaker JumpStart",
    ],
    links: [
      "https://aws.amazon.com/blogs/machine-learning/mitigate-hallucinations-through-retrieval-augmented-generation-using-pinecone-vector-database-llama-2-from-amazon-sagemaker-jumpstart/",
    ],
  },

  langchain: {
    titles: ["LangChain AI Handbook"],
    links: ["https://www.pinecone.io/learn/series/langchain/"],
  },

  openai: {
    titles: [
      "Generative Question-Answering with Long-Term Memory",
      "OpenAI's Text Embeddings v3",
    ],
    links: [
      "https://www.pinecone.io/learn/openai-gen-qa/",
      "https://www.pinecone.io/learn/openai-embeddings-v3/",
    ],
  },

  snowflake: {
    titles: [
      "Snowpark Container Services: Securely Deploy and run Sophisticated Generative AI and full-stack apps in Snowflake",
    ],
    links: [
      "https://www.snowflake.com/blog/snowpark-container-services-deploy-genai-full-stack-apps/",
    ],
  },
};

let isScrollListenerAdded = false;
let scrollListener = null;

const observer = new MutationObserver(function (mutations) {
  mutations.forEach(function (mutation) {
    if (mutation.type === "childList") {
      const [path, page] = window.location.pathname.split("/").slice(1);

      // Remove version picker from all but /reference/ pages
      const versionToggle = document.getElementById(
        "headlessui-menu-button-:r0:"
      );
      
      if (path !== "reference" && page !== "reference") {
        versionToggle.style.visibility = "hidden";
      } else {
        versionToggle.style.visibility = "visible";
      }

      if (path === "integrations" && page === "overview") {
        const toc = document.querySelector("#table-of-contents");
        if (toc) toc.style.display = "none";

        const header = document.querySelector("#header");
        if (header) header.style.display = "none";

        const existingBanner = document.querySelector("#integrations-banner");
        if (!existingBanner) {
          const banner = document.createElement("div");
          banner.id = "integrations-banner";

          const h1 = document.createElement("h1");
          h1.textContent = "Integrations";
          banner.appendChild(h1);

          const p = document.createElement("p");
          p.textContent = "Build powerful workflows with our partners";
          banner.appendChild(p);

          const navbar = document.getElementById("navbar");
          navbar.insertAdjacentElement("afterend", banner);
        }

        // Remove content padding
        const contentContainer = document.querySelector("#content-container");
        contentContainer.firstElementChild.style.paddingTop = "1rem";

        // Move sidebar
        const sidebar = document.querySelector("#sidebar");
        sidebar.style.top = "20.5rem";

        // Handle sidebar
        const handleSidebarScroll = () => {
          let maxScroll = 200;
          let startPosition = 20.5;
          let endPosition = 7.3;

          if (window.scrollY <= maxScroll) {
            let scrollFraction = window.scrollY / maxScroll;
            let positionDifference = startPosition - endPosition;
            let currentPosition =
              startPosition - scrollFraction * positionDifference;
            sidebar.style.top = `${currentPosition}rem`;
          } else {
            sidebar.style.top = `${endPosition}rem`;
          }
        };

        if (!isScrollListenerAdded) {
          scrollListener = handleSidebarScroll;
          window.addEventListener("scroll", scrollListener);
          isScrollListenerAdded = true;
        }
      } else {
        // Remove sidebar scroll listener
        if (isScrollListenerAdded && scrollListener !== null) {
          window.removeEventListener("scroll", scrollListener);
          isScrollListenerAdded = false;
        }

        // remove the banner
        const existingBanner = document.querySelector("#integrations-banner");
        if (existingBanner) {
          existingBanner.remove();
        }

        // Move sidebar
        const sidebar = document.querySelector("#sidebar");
        sidebar.style.top = "7.3rem";

        if (path === "integrations" && page !== "overview") {
          // Insert back button
          const backButton = document.querySelector("#back-button");
          if (!backButton) {
            const link = document.createElement("a");
            link.id = "back-button";
            link.href = "/integrations/overview";
            link.textContent = "Back to Integrations";
            link.insertAdjacentHTML(
              "afterbegin",
              '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="17" viewBox="0 0 16 17" fill="none"><path d="M10.4693 5.44L9.5293 4.5L5.5293 8.5L9.5293 12.5L10.4693 11.56L7.41596 8.5L10.4693 5.44Z" fill="#1B17F5"/></svg>'
            );

            const header = document.querySelector("#header");
            header.insertAdjacentElement("afterbegin", link);
          }
          // Add related articles
          switch (page) { /* Hide related articles for now
            case "airbyte":
              addRelatedArticles(
                relatedArticles.airbyte.titles,
                relatedArticles.airbyte.links
              );
              break;
              airbyte;
            case "amazon-bedrock":
              addRelatedArticles(
                relatedArticles.bedrock.titles,
                relatedArticles.bedrock.links
              );
              break;
            case "amazon-sagemaker":
              addRelatedArticles(
                relatedArticles.sagemaker.titles,
                relatedArticles.sagemaker.links
              );
              break;
            case "langchain":
              addRelatedArticles(
                relatedArticles.langchain.titles,
                relatedArticles.langchain.links
              );
              break;
            case "openai":
              addRelatedArticles(
                relatedArticles.openai.titles,
                relatedArticles.openai.links
              );
              break;
            case "snowflake":
              addRelatedArticles(relatedArticles.snowflake.titles, relatedArticles.snowflake.links)
              break; */
            default:
              break;
          }
        }
      }
    }
  });
});

observer.observe(document.body, { childList: true, subtree: true });

// Replace the cta button since replacing the svg via css ::after is not working
window.addEventListener("load", () => {
  const ctaButton = document.querySelector("#topbar-cta-button");

  if (ctaButton) {
    ctaButton.innerHTML = "";
    const a = document.createElement("a");
    a.href = "https://app.pinecone.io/?sessionType=signup";
    a.target = "_blank";
    a.textContent = "Sign up free";

    const svg =
      '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="none"><path d="M8.08906 5L6.91406 6.175L10.7307 10L6.91406 13.825L8.08906 15L13.0891 10L8.08906 5Z" fill="white"/></svg>';

    a.insertAdjacentHTML("beforeend", svg);
    ctaButton.appendChild(a);
  }
});


Pinecone Docs

Home

Guides

Reference

Examples

Integrations

Tools

Troubleshooting

Releases

Sign up free

Status

Support

Log In

The `list` operation lists the IDs of vectors in a single namespace of a serverless index. An optional prefix can be passed to limit the results to IDs with a common prefix.

`list` returns up to 100 IDs at a time by default in sorted order (bitwise/"C" collation). If the `limit` parameter is set, `list` returns up to that number of IDs instead. Whenever there are additional IDs to return, the response also includes a `pagination_token` that you can use to get the next batch of IDs. When the response does not include a `pagination_token`, there are no more IDs to return.

For guidance and examples, see [Get record IDs](https://docs.pinecone.io/docs/get-record-ids).

**Note:** `list` is supported only for serverless indexes.

List vector IDs

ApiKeyAuth

An introduction to the Pinecone vector database.

Overview

Pinecone overview

Quickstart

This guide explains how to authenticate API calls to your Pinecone project.

Authentication

Understanding organizations

Change your billing plan

Set up billing through AWS Marketplace

Set up billing through Azure Marketplace

Set up billing through GCP Marketplace

Understanding subscription status

Understanding cost

Monitoring your usage

Managing cost

Single sign-on with Okta

Manage organization members

Understanding projects

Create a project

Manage project members

Rename a project

Set a project pod limit

Understanding indexes

Create an index

View index information

Back up an index

Delete an index

Using namespaces

Choosing a pod type and size

Configure pod-based indexes

Scale pod-based indexes

Understanding collections

Convert a gcp-starter index to serverless

Upsert data

Query data

Fetch data

Update data

Delete data

List record IDs

Get an index endpoint

Filtering with metadata

Manage RAG documents

Understanding hybrid search

Encode sparse vectors

Upsert sparse-dense vectors

Query sparse-dense vectors

Using public Pinecone datasets

Creating and loading private datasets

Migrate to the new API

Moving to production

Performance tuning

Monitoring

Understanding multitenancy

Introduction

The `upsert` operation writes vectors into a namespace. If a new value is upserted for an existing vector ID, it will overwrite the previous value.

For guidance and examples, see [Upsert data](https://docs.pinecone.io/docs/upsert-data).

Upsert vectors

The `query` operation searches a namespace, using a query vector. It retrieves the ids of the most similar items in a namespace, along with their similarity scores.

For guidance and examples, see [Query data](https://docs.pinecone.io/docs/query-data).

Query vectors

The `fetch` operation looks up and returns vectors, by ID, from a single namespace. The returned vectors include the vector data and/or metadata.

For guidance and examples, see [Fetch data](https://docs.pinecone.io/docs/fetch-data).

Fetch vectors

The `update` operation updates a vector in a namespace. If a value is included, it will overwrite the previous value. If a `set_metadata` is included, the values of the fields specified in it will be added or overwrite the previous value.

For guidance and examples, see [Update data](https://docs.pinecone.io/docs/update-data).

Update a vector

The `delete` operation deletes vectors, by id, from a single namespace.

For guidance and examples, see [Delete data](https://docs.pinecone.io/docs/delete-data).

Delete vectors

The `describe_index_stats` operation returns statistics about the contents of an index, including the vector count per namespace and the number of dimensions, and the index fullness.

Serverless indexes scale automatically as needed, so index fullness is relevant only for pod-based indexes.

For pod-based indexes, the index fullness result may be inaccurate during pod resizing; to get the status of a pod resizing process, use [`describe_index`](https://www.pinecone.io/docs/api/operation/describe_index/).

Get index stats

This operation returns a list of all indexes in a project.

List indexes

This operation deploys a Pinecone index. This is where you specify the measure of similarity, the dimension of vectors to be stored in the index, which cloud provider you would like to deploy with, and more.

For guidance and examples, see [Create an index](https://docs.pinecone.io/docs/create-an-index#create-a-serverless-index).

Describe an index

This operation deletes an existing index.

This operation specifies the pod type and number of replicas for an index. It applies to pod-based indexes only. Serverless indexes scale automatically based on usage.

Configure an index

This operation returns a list of your Pinecone collections.

Serverless indexes do not support collections.


List collections

This operation creates a Pinecone collection.

Serverless indexes do not support collections.


Create a collection

This operation gets a description of a collection.

Serverless indexes do not support collections.


Describe a collection

This operation deletes an existing collection.

Serverless indexes do not support collections.


Delete a collection

Pinecone clients

Community clients

Serverless architecture

Pod-based architecture

Quotas and rate limits

Known limitations

Security

Notebooks

Sample apps

Utilities

Reference architectures

Pinecone integrations enable you to build and deploy AI applications faster and more efficiently. Integrate Pinecone with your favorite frameworks, data sources, and infrastructure providers.

Airbyte

Confluent

Using Databricks and Pinecone to create and index vector embeddings at scale

Databricks

Snowflake

Pinecone as a Knowledge Base for Amazon Bedrock

Amazon Bedrock

Amazon SageMaker

Using Haystack and Pinecone to keep your NLP-driven apps up-to-date

Haystack

Using LangChain and Pineone to add knowledge to LLMs

LangChain

Using LlamaIndex and Pinecone to build semantic search and RAG applications

LlamaIndex

Amazon Web Services (AWS)

Azure

Google Cloud Platform (GCP)

Pulumi

Using Terraform to manage Pinecone resources

Terraform

Vercel

Anyscale

Using Cohere and Pinecone to generate and index high-quality vector embeddings

Cohere

Using Hugging Face Inference Endpoints and Pinecone to generate and index high-quality vector embeddings

Hugging Face Inference Endpoints

Using OpenAI and Pinecone to combine deep learning capabilities for embedding generation with efficient vector storage and retrieval

OpenAI

Datadog

New Relic

Using TruLens and Pinecone to evaluate grounded LLM applications

TruLens

Become a Pinecone partner

Register your integration

Connect to Pinecone with an embedded widget

Contact Support

How to work with Support

Pinecone Support SLAs

Login code issues

Custom data processing agreements

Delete your account

Billing disputes and refunds

Exporting indexes

Waiting for index creation to be complete

Selecting index type and size

How and when to increase the size of an index

Using namespaces instead of several indexes

Using namespaces vs. metadata filtering

Restrictions on index names

Returning all vectors in an index

Vertically downscaling

Deleting a namespace

Pods are full

Parallel queries

Minimize latencies

Embedding values changed when upserted

How and when to add replicas

Keeping customer data separate in Pinecone

Limitations of querying by ID

Creating and managing vectors with metadata

Handling large numbers of deletes by metadata

Metadata re-configuration

Metadata string value returned as a datetime object

Removing a metadata field from a record

Index creation error - missing spec parameter

Serverless index creation error - max serverless indexes

Serverless index connection errors

Error: Handshake read failed when connecting

Error: Pinecone has no attribute 'from_texts'

Error: Cannot import name 'Pinecone' from 'pinecone'

Python AttributeError: module pinecone has no attribute init

General FAQs

Best Practices

Differences between Lexical and Semantic Search regarding relevancy

Node.JS Troubleshooting

CORS Issues

Debugging model vs. Pinecone recall issues

Understanding and resolving non-indexed field filter issues

Unable to pip install

2024 releases

2023 releases

2022 releases

API lifecycle policy

<strong>Warning:</strong> The legacy version of the API, which requires regional URLs for control plane operations, is deprecated as of April 15, 2024 and will be removed in a future, to be announced, release. For more information, see <a href='https://docs.pinecone.io/guides/operations/migrate-to-the-new-api'>Migrate to the new API</a>.

The `Upsert` operation writes vectors into a <a href='https://docs.pinecone.io/docs/namespaces'>namespace</a>.
 If a new value is upserted for an existing vector id, it will overwrite the previous value.

Upsert

<strong>Warning:</strong> The legacy version of the API, which requires regional URLs for control plane operations, is deprecated as of April 15, 2024 and will be removed in a future, to be announced, release. For more information, see <a href='https://docs.pinecone.io/guides/operations/migrate-to-the-new-api'>Migrate to the new API</a>.

The `Query` operation searches a <a href='https://docs.pinecone.io/docs/namespaces'>namespace</a>, using a query vector.
 It retrieves the ids of the most similar items in a namespace, along with their similarity scores.

Query

<strong>Warning:</strong> The legacy version of the API, which requires regional URLs for control plane operations, is deprecated as of April 15, 2024 and will be removed in a future, to be announced, release. For more information, see <a href='https://docs.pinecone.io/guides/operations/migrate-to-the-new-api'>Migrate to the new API</a>.

The `Fetch` operation looks up and returns vectors, by ID, from a single <a href='https://docs.pinecone.io/docs/namespaces'>namespace</a>.
 The returned vectors include the vector data and/or metadata.

Fetch

<strong>Warning:</strong> The legacy version of the API, which requires regional URLs for control plane operations, is deprecated as of April 15, 2024 and will be removed in a future, to be announced, release. For more information, see <a href='https://docs.pinecone.io/guides/operations/migrate-to-the-new-api'>Migrate to the new API</a>.

The `Update` operation updates vector in a <a href='https://docs.pinecone.io/docs/namespaces'>namespace</a>.
 If a value is included, it will overwrite the previous value.
 If a set_metadata is included, the values of the fields specified in it will be added or overwrite the previous value.

Update

REST API

Clients

Architecture

Miscellaneous

List vector IDs

Authorizations

Query Parameters

Response