Recently, one of my customers ran into an issue using Pinecone’s integrated inference capabilities. It was a great reminder of how powerful this feature can be, but also of the small edge cases we need to watch out for. In this post, I’ll explain what integrated inference is, what happened with my customer, and how we solved it with a simple workaround.What is Integrated Inference?Integrated inference is Pinecone’s built-in offering of embedding models that generate vector embeddings inline. Normally, creating embeddings requires a chain of extra steps: choosing and hosting a model, provisioning GPUs or servers, managing scaling, and wiring in code to call the model separately from your database. Even if you use an external API, you still need to make multiple calls, handle retries, and pass results from the embedding service into your vector database. With integrated inference, Pinecone collapses all of these steps into a single API call, letting you index and query with embeddings without managing any of the complexity yourself.Traditionally, embedding for Retrieval Augmented Generation (RAG) or search pipelines looks like this:Take your corpus of text: paragraphs, documents, even books.Break the text into chunks that fit into the input size of your chosen embedding model.Pass each chunk through the embedding model to generate vectors.Store those vectors in your vector database.When querying, embed the query text and search for nearest neighbors in the database.Conceptually, embedding is simple: text in, vector out. In practice, though, it adds friction to every workflow. Most teams today call an external API like OpenAI or Cohere to generate embeddings. That means every time you want to index data, you have to call one API to create vectors, then call your vector database to store them. You also need to keep track of model compatibility, embedding dimensions, scaling limits, and API retries. If you choose to self-host, the burden grows even heavier with GPU provisioning, monitoring, and scaling. And no matter which path you take, you still have to glue it all together with frameworks like LangChain, Langflow, or your own custom code.With integrated inference, you skip all that. You can send your data to Pinecone and let the platform generate embeddings automatically as part of the upsert. That means less infrastructure, fewer moving parts, and more time spent building valuable applications instead of plumbing.A Simple ExampleHere’s what it looks like in practice using the upsert_records() method, which handles embeddings behind the scenes:# Import the Pinecone library