Pinecone Reviews

I have used Pinecone in two main contexts. First, in a client project where I implemented a vector search system over a corpus of financial documents, balance sheets, trial balances, and invoices. I stored document embeddings in Pinecone and used it for similarity-based lookup and recommendation features. Second, I built a RAG-based document chatbot where Pinecone served as a retrieval layer. I would chunk documents, generate embeddings, store them in Pinecone, and then retrieve relevant context for an LLM to answer user queries.

Adding vector search to the client project significantly improved how quickly users could find relevant financial documents. Instead of manual keyword search, they got semantically relevant answers. For a RAG chatbot, Pinecone made retrieval fast and accurate enough to power real-time question answering over documents, which would have been impractical with brute-force search.

The best features Pinecone offers, in my experience, include strong performance and reliability. However, the free tier is somewhat limited. If you are experimenting with a larger data set, you hit the limits quickly during development. Cost can scale up as your index size grows, which is something to plan for. Also, for someone just starting out, understanding the right embedding dimensions, indexing strategies, and metadata filtering takes some trial and error. More guided tutorials or best practice templates for common use cases like RAG would help.

Before I integrated Pinecone, the client was doing keyword-based search over their financial documents, balance sheets, invoices, and similar items. It was slow and often returned irrelevant results because keyword matching does not capture semantic meaning. Once I switched to vector search with Pinecone, users could find contextually relevant documents much faster. Instead of sifting through dozens of keyword mismatches, they would get the most semantically similar documents right at the top. That is a real workflow improvement that saved them hours every week on document retrieval.

On the integration side, Pinecone's Python SDK is straightforward. It integrates well with the usual AI stack like LangChain and LlamaIndex. That was smooth for me. Where it could improve is around documentation for edge cases. For instance, handling metadata filtering at scale, understanding the right embedding dimensions for different use cases, and best practices for indexing strategies. Those topics felt sparse in the documentation. More real-world tutorials specific to common patterns like RAG or recommendation systems would help developers ramp up faster.

On support, the community is helpful, but if you hit something tricky and you are on a lower-tier plan, getting quick answers can be slow. Better-tiered support or more comprehensive troubleshooting guides would be valuable, especially for production deployments where latency is critical.

I have been using it for about one year.

Pinecone is very stable for me. I have had excellent uptime and cannot recall any significant outages affecting my production indexes over the past year.

Scalability has been solid. I have grown from around 10,000 vectors to 500,000 without hitting any hard times or performance issues. Pinecone handles that growth transparently. I do not have to manually re-partition data or manage sharding myself like I would with self-hosted solutions. Query latency remained consistent even as the index grew, which is impressive. The main constraint is not technical scalability, it is cost. As your index size grows, your monthly bill grows proportionally. So you need to be thoughtful about what you are indexing rather than just throwing everything at it.

Customer support is decent but has some limitations. The community Slack channel is helpful, and I can get answers from their users and Pinecone engineers fairly quickly. What has been useful for me is that if you are on a lower-tier plan, getting direct support can be slow. For production issues where you need quick solutions, having more responsive support channels would be beneficial. The documentation and troubleshooting guides are good, but they do not always cover edge cases or complex scenarios I might run into.

Before Pinecone, I was using a more basic approach with keyword-based search using Elasticsearch. It worked for simple use cases, but keyword mismatching did not capture semantic meaning, so relevance was poor. I also experimented briefly with building my own vector search solution using Milvus, which is an open-source vector database. The appeal was cost savings, but it required dedicated DevOps effort to deploy, maintain, scale, and monitor. That overhead was not worth it given my team size.

I switched to Pinecone because it gave me the semantic search quality I needed without the operational burden. It was a trade-off: slightly higher cost compared to self-hosting Milvus, but much lower operational complexity and faster time to production. For a lean team, that made sense. Elasticsearch could not do semantic search well, and managing Milvus myself was too much overhead. Pinecone hit the sweet spot between capability and operational simplicity.

The deployment process itself was fairly straightforward. Creating indexes through Pinecone's dashboard and configuring the index settings like dimension and metric type took maybe an hour to get right. The Python SDK integration was smooth, and connecting my application to the indexes worked without much friction.

Where it got a bit tricky was the initial work around embeddings and index configuration. I had to experiment with embedding dimensions, whether to use 384, 768, or 1536 dimensions, depending on my use case. That affected both performance and cost. I also spent time getting metadata filtering right for financial documents, since I needed to filter by document type and date ranges alongside semantic search. Overall, this was not a major blocker, but there was definitely a learning curve on the configuration side. Once I got it dialed in, running it in production has been easy.

The clearest ROI is time saved on documentation retrieval. That 15 to 20 minutes per user per day adds up. If you have a team of, say, 10 financial analysts, that is roughly 150 to 200 minutes saved daily, or about 30 to 40 hours per week across the team. Over a year, that is substantial.

In terms of direct cost savings, I did not need to hire additional DevOps staff to manage a vector database myself. The managed service handled that, so there is an implicit cost avoidance there. On the revenue side, for my client, the faster document retrieval made their service more competitive and improved user satisfaction, which likely helped with retention, though I did not track the metric explicitly. The clearest financial metric is probably this: the cost of Pinecone, which is a few hundred dollars monthly, is easily offset by the productivity gains from not having analysts spend hours manually searching documents. The payback period was basically immediate once I deployed it.

Pinecone charges based on index size and API requests. I am paying for storage and compute. The free tier is generous for experimentation, but it gets maxed out pretty quickly if you are working with real-world data sets. For my setup, initial costs were low since I started small, but as I scaled to 500,000 vectors, the monthly bill grew noticeably.

I did evaluate a few alternatives. Milvus was one. It is open-source and cost-effective, but the operational overhead was a concern. I also looked at Weaviate, which is another managed vector database option. It has some nice features around hybrid search and knowledge graphs, but it felt a bit more complex than what I needed, and pricing was comparable to Pinecone anyway.

In the end, Pinecone won out because it offered the best balance: managed infrastructure, so no DevOps headaches, solid query performance, straightforward Python integration, and transparent pricing.

Pinecone is especially valuable for teams that want a managed vector database without the overhead of self-hosting something like Milvus or Weaviate. If you are building RAG systems, semantic search, or recommendation features and you want something that just works out of the box, Pinecone is a solid choice.

The main impact was around speed and relevance. Without fast vector retrieval, real-time question answering over documents would have been too slow to be practical. Pinecone made that workflow possible in the first place, rather than just improving it.

On reliability, I have had really good uptime and cannot recall any significant outages affecting my production indexes. Pinecone's infrastructure is managed, so they handle failover and redundancy behind the scenes. One thing to note is that during peak usage times, I have occasionally seen slightly higher latency, maybe 200 to 300 milliseconds instead of the usual 50 to 100 milliseconds.

Pinecone handles scaling pretty in practice. That is one of the main selling points of a managed service. I do not have to manually shard or manage replicas myself like I would with a self-hosted solution. I have scaled from maybe 10,000 vectors to around 500,000 vectors over the course of the year, and Pinecone handled that transparently. Query latency stayed fast throughout. The main challenge was not performance itself, it was cost. As your index size grows, you are paying more for storage and compute resources. I had to be strategic about what embeddings I kept and which documents I actually needed to index. Scaling works smoothly, but you need to plan for cost implications early on rather than discovering them later when your bill starts to grow.

I would rate Pinecone 8 out of 10. The reason it is not a full 10 is mainly two things: the free tier limitations hit you fast when you are experimenting with large data sets, and the documentation could go deeper on real-world patterns like RAG and metadata filtering. However, the reason it is still an 8 and not lower is because the core product is really strong. Managed infrastructure means zero maintenance headaches. Query performance is fast and reliable. The Python SDK integrates smoothly with tools like LangChain, and similarity search results are genuinely relevant. For what it does—managed vector search in production—it delivers. Those last two points are just areas where it could go from great to excellent.

My main use case for Pinecone involves storage of chat data, specifically chat transcripts, and retrieval of matched chat messages.

We store chat transcripts as vectors in Pinecone. When we have a new chat message, we utilize a retrieval mechanism to match and find the last five messages so that it can act as a memory. Essentially, Pinecone serves as a long-term memory for our application, while we use Redis for our short-term memory.

We were looking at multiple options for a vector database, and we found Pinecone to be the easiest to integrate into our solution. Plus, it has a very generous free tier, which helps us as a startup.

The best features Pinecone offers are quick setup and good indexing for us. The retrieval mechanisms are fast, and the integration with Python as with JavaScript and TypeScript libraries that Pinecone provides are very robust. Authentication is also very good.

The namespaces feature allows us to break down or store data for each user separately, reducing interference and maintaining privacy as an important feature.

Pinecone has positively impacted our organization by enhancing efficiency for the team, and the long-term effect has been that the chats have become much more personalized due to the memory added through a vector database. We are seeing that the trainees getting trained on the platform are more satisfied with the results or messages generated by AI.

One major issue I have noticed with Pinecone is that it does not allow me to search based on metadata. This can cause problems because while vector indexing or vector search is good, if you populate certain categories of messages or metadata into a vector database, searching through the data using the filter of metadata is not possible.

For our requirements, Pinecone is more than enough. If improvements are required, I would suggest taking a look at the embeddings and possibly improving the embedding sizes.

I have been using Pinecone with code for one and a half years.

Pinecone is very stable.

Pinecone's scalability is pretty decent for us, as we have not encountered issues. We are storing close to around 600K items or entries in the database, and our indexing and retrievals are within seconds, often in microseconds.

The customer support of Pinecone is very good; you send an email and receive a response within a few hours, typically four to five hours. Additionally, you can set up a call if needed.

Since we are on the minimal plan, I would rate the customer support around 8 out of 10.

Positive

We previously tried setting up with Weaviate and another solution. During my research, we checked out a couple of options, including an on-prem solution that I tried to set up on my machine, but it was very painful, so we went with the cloud service provider because the setup was nearly nonexistent.

The setup cost for us is nil, and the licensing and pricing are pretty decent. Pinecone works on the storage amount, so our bills are pretty low, and we are good.

The setup cost for us is nil, and the licensing and pricing are pretty decent. Pinecone works on the storage amount, so our bills are pretty low, and we are good.

Before choosing Pinecone, I evaluated a few options, including Weaviate.

I would suggest that Pinecone is one of the best options available. I would rank it in the top three for vector databases and qualify it as number one in the market. There are many others such as Weaviate and Milvus, but they come with certain issues such as lacking a free tier or having a very low one.

Moreover, solutions like Milvus and FAISS are on-prem, which makes setup and stability a pain, primarily catering to big enterprises. For startups, Pinecone is indeed the best.

We are just a client of Pinecone; we do not have any other business relationship.

Rating: 4/5

My main use case for Pinecone is to provide managed vector search for high-dimensional data, ideal for AI apps like semantic search and RAG, where I identify reasons for brand de-growth for big pharma brands through a sales agent and a process agent, utilizing Pinecone for easy use of RAG and vector embeddings with high-dimensional data.

In my workflow, I have used Pinecone in agentic AI and RAG pipelines that require quick scaling without infrastructure management, aligning well with Python workflows and similar to PGVector extensions.

Pinecone stands out as a fully managed, cloud-native vector database in my brand de-growth analysis, contrasting with libraries such as FAISS or self-hosted options such as Milvus, as it prioritizes ease for production AI apps, allowing easy deployment as a fully managed serverless application with auto-scaling clusters and pay-per-usage cost, making it ideal for production RAG and AI chatbots by using guided search to retrieve outputs from Pinecone vector database.

The best feature Pinecone offers is its scalability since it auto-scales clusters, and its fully managed deployment as a serverless solution is one of the best aspects. Additionally, Pinecone is easily integratable with Python and its ease of use with Python is phenomenal.

Pinecone's scalability allows it to handle billions of vectors with auto-sharding, a capability other databases do not provide. Pinecone is stable, excelling in managed production scaling.

Pinecone has positively impacted my organization by enabling fast similarity searches using metrics such as cosine or Euclidean distance on billions of vectors with low latency around 20 to 100 milliseconds, with key capabilities including hybrid search combining semantic and keyword, real-time updates, filtering, and re-ranking.

The low latency and hybrid search from Pinecone have significantly improved my team's productivity, as when coupled with the RAG pipeline, it has enhanced solution accuracy, reducing query response time to around 10 to 15 seconds compared to 40 to 60 seconds without RAG.

From a cost perspective, I believe Pinecone is a bit expensive compared to other solutions such as FAISS and Milvus, which are free and open source, while Weaviate is more cost-effective at scale, so I would request improvement in Pinecone's pricing structure.

Furthermore, in cases of GPU-accelerated experiments requiring control over indexing strategies, I would prioritize FAISS due to its cost-free prototyping, extreme customization, and high-performance local computation, as Pinecone lacks custom GPU support compared to FAISS and fine-tuned algorithms.

I have been using Pinecone for around two years.

Pinecone is stable, excelling in managed production scaling.

Pinecone's scalability allows it to handle billions of vectors with auto-sharding, a capability other databases do not provide, and I have experienced no issues with scalability.

Customer support for Pinecone is tied to billing plans, generally starting with standard tier access through console tickets, although I feel free support is lacking.

Before adopting Pinecone, we used a Power BI dashboard to identify brand RCA, but it involved many manual and friction points in navigating boards, which did not provide clear insights, while Pinecone's multi-agent architecture has cut down the analysis time from around one week or 10 days to just one day.

I evaluated ChromaDB before implementing Pinecone.

Pinecone is deployed in my organization on a private cloud.

We utilize enterprise licensing for Pinecone.

We have seen a return on investment as we have reduced the work of 10 FTEs, allowing the Salesforce analytics team to self-serve the data they formerly depended on other business analysts to pull, effectively consolidating the work into one person with the integration of this solution.

We utilize enterprise licensing for Pinecone, and while I cannot specify the exact costs, it should be approximately around $100 to $150 per month.

In cases of GPU-accelerated experiments requiring control over indexing strategies, I would prioritize FAISS due to its cost-free prototyping, extreme customization, and high-performance local computation, as Pinecone lacks custom GPU support compared to FAISS and fine-tuned algorithms.

I advise those looking to use Pinecone to consider it for building a serverless, scalable solution as it achieves millisecond searches across billions of vectors using optimized indexing such as HNSW, with operational simplicity as it is fully managed and serverless, able to be upgraded without infrastructure operations unlike FAISS or ChromaDB.

Overall, I feel Pinecone excels in operational simplicity and scalability, making it a flexible solution ideal for real-time RAG or agentic systems. I would rate this product a 7 out of 10.

We are using Pinecone because we have a good amount of documents which we use on a daily basis from our vendors. Based on those documents, we need to provide information to the end customer for that particular company. We have a UI where customers can ask any questions related to anything in the financial domain. We need to provide the latest information, so we are dynamically doing the chunking with the help of an OpenAI LLM model and then inserting into Pinecone. In Pinecone, we are using a very high dimension vector space, almost more than 3K dimension size. We then perform similarity search and provide the final response to the UI. For our RAG system implementation, we are using Pinecone.

There are multiple factors that impressed me while using Pinecone. I had an option to use Milvus as well, but I preferred Pinecone. The first is the UI. Pinecone's UI is really strong. If I need to do some debugging on the backend side, I simply log into the UI and can perform operations based on my demand. This is a valuable UI feature.

Second is the scalability option. I can either define my own workers or use the auto-scaling feature. From an enterprise application and scalability perspective, this is very useful. We had an incident during a Black Friday sale and other occasional events that directly impacted our product traffic. Because we selected the auto-scaling feature in Pinecone, it automatically handled all the traffic spikes and we did not face any performance issues.

Ease of troubleshooting is another valuable feature. If any transaction fails and we need to check and debug each transaction, we can perform a text search on the UI. Based on the text search, we get all the related vectors on the UI. The UI definitely helps us from a troubleshooting perspective. Selecting the infrastructure is also an important option. I can create multiple indexes based on demand so that it will not become messy for our enterprise application. Pinecone is the backbone of the entire system, helping us with cost and time savings.

I have a suggestion to expand the vector size in Pinecone. Right now, whatever the limit Pinecone is suggesting, I would recommend increasing that option. Currently, I believe it is around 3K, but if I want to go to 4K, 5K, or something higher, that would be beneficial. Embedding models are coming into the market and they are providing good amounts of vector sizes. Try to encapsulate all these features into Pinecone.

I have two main suggestions from my side. One is to increase the vector size. Currently, it is supporting only around 3K vector size, and I would recommend increasing that. The second suggestion involves creating a feature similar to LangSmith, which is a monitoring tool. In LangSmith, end-to-end API calls can be analyzed, showing what request came from the customer, what vector search was performed, what prompt was created, what call was given to the LLM, and what response was received from the LLM to the UI. The whole journey can be captured. I would appreciate if Pinecone could provide this capability from their side. I understand that Pinecone cannot capture the LLM call and everything. However, if it is possible, I could use the API key of Pinecone in my code where I can enable these feature logs and see all these things on the Pinecone dashboard.

The major improvement I am expecting from Pinecone is increased vector size. The second improvement would be to provide end-to-end debugging or the whole end-to-end call journey as a GenAI product, showing how the end-to-end journey works for a single request. If I am able to see the whole process on the Pinecone dashboard, it would be really valuable.

I am using Pinecone as an enterprise application in my organization for almost three years.

I do not have specific metrics, but I can give some high-level approximations. The task that was happening before developing this product was taking around one hour, but now it is done in hardly one or two minutes. So from 60 minutes to one or two minutes, you can assume how much cost savings we are achieving. Additionally, we are engaging customers much better through the UI. Previously, customers used to wait for 60 minutes. Now they get results within one or two minutes. We are definitely increasing our customer database.

Milvus is another contender that we considered while deciding on a vector database. I suggested Pinecone because of its good amount of quality compared to Milvus. However, Milvus has the capability to handle any vector size, which is missing in Pinecone.

I have been using Pinecone for two years, starting with agents and RAG models. My main use case for Pinecone is to build a RAG model to create chatbots for enterprise.

We created a chatbot and used Pinecone for storing the embeddings generated to create that RAG model. This chatbot helps people understand more about their documentation. Users can ask queries, and it retrieves the nearest vector embedding, passes it to the LLM, and comes back with the nearest possible available context.

Primarily, I am using Pinecone for chatbots only. However, there are some additional use cases. Pinecone helps with RAG, semantic search, and a combination of hybrid search with hybrid vector search plus semantic search. Some of my teammates are also using it for creating recommendation systems for our customers.

Pinecone offers fully managed infrastructure, so there is no need to manage servers, sharding, indexing, or scaling, which reduces DevOps overhead significantly. It has high performance and low latency.

Pinecone's high performance and low latency have made a difference for my team since I am able to drastically reduce the retrieval time. It provides millisecond-level similarity search across billions or millions of vectors and uses optimized approximate nearest neighbor algorithms to provide the results, which really reduces the overall response time.

The developer experience with Pinecone is also good, with very clear, well-maintained documentation and minimal setup required, and it is perfectly built for handling AI use cases.

Pinecone has positively impacted my organization by helping us build those RAG models. Those chatbots help because earlier the users and specialists used to go to the documentation and refer to it manually, but with Pinecone integration retrieval model, I am able to ask queries to the chatbot, and it provides the appropriate context text along with citations. This helps organizations transition from keyword-based systems to semantic systems.

Pinecone is not open-source. The cost can escalate based on the pay-as-you-go pricing, so when there are high volume large embeddings, the cost would automatically rise. Additionally, there is no on-premises application available; it is only cloud-based, which becomes a problem for industries that are highly regulated. Since it is into vector, there is no particular conversion for joins and structured queries, which becomes a problem. A system that could automatically convert into structured SQL queries would help increase overall acceptance.

I have been using Pinecone for two years, starting when I began working with agents and RAG models.

I have not faced any issues with Pinecone; the reliability factor is there. It is able to withstand the enormous data load and manage it effectively. Till now, I have not experienced any downtime. Pinecone is stable.

Pinecone handles scaling as my data grows by providing good response time even though I have enormous amounts of data. It uses horizontal scaling, which helps, and it also does automatic sharding; it splits vector data into shards, and each shard can be independently indexed and queried, helping with parallel query execution. I would rate Pinecone's scalability an eight or nine out of ten.

Pinecone's customer support is good. I would rate the customer support a nine out of ten.

I did not use a different solution before Pinecone; I started with Pinecone after getting reviews from Trustpilot and G2. I understood that it is designed to be very easy to use compared to FAISS and Weaviate.

The integration of Pinecone with my existing tech stack was a very good experience. The developer documents were up to the mark, clearly documented, and it exposes clean REST and SDK interfaces. The core operations of creating an index, upserting a vector, or querying a vector are minimal, making it a plug-and-play experience with the LLM ecosystem. It works seamlessly with LangChain, LlamaIndex, and other embeddings.

Overall, the time to go through the documentation has drastically reduced. I have achieved a 30 to 40% reduction in time to go through the documentation because now I can ask a query from the chatbot, and it provides the result with the appropriate source link. Pinecone helps me save about two to three hours daily because of the manual effort required to go through the documentation. Now it is fast; at my fingertips, I can get any information, allowing me to go through that guideline.

Pricing was handled by the procurement team, but it follows a usage-based pricing model, and I have to pay for storage, read operations, and write operations. Sometimes it just exceeds, so having a quota or limit would help.

I evaluated FAISS and Weaviate before choosing Pinecone.

If you are looking for a highly scalable, performance-oriented, highly reliable system, go for Pinecone. It is especially designed for handling AI use cases. I would give Pinecone a rating of seven out of ten.

I feel Pinecone is secure for most enterprise use cases, with strong controls around data isolation, encryption, and access management. It uses HTTPS and TLS encryption to protect data during API calls, and the data at rest is also encrypted. It follows the multi-tenant isolation model, which is managed through indexes on namespaces. The security posture is at the highest level, which is what I need from an enterprise point of view. The documentation is top-notch; it is highly quality, developer-friendly, and production-oriented, especially for different use cases like RAG and semantic search. It is designed to get teams from zero to working systems quickly, with clear starting guides, impact explanation, and strong code examples provided.

We're using Pinecone to build our RAG pipeline. We need a vector database, and we have a lot of options in the market. RAG is the biggest use case for us.

The first thing is that we've always been using AWS. AWS provides OpenSearch serverless out of the box, but OpenSearch happens to be pretty expensive because you have to pay per hour of use if you want to have an OpenSearch server alive. It's billed as the number of OCUs. Pinecone, on the other hand, is pay-as-you-go on the number of queries. You only pay for the queries that you hit.

Pinecone's integration with AWS was seamless. All we had to do was take one of the API keys and upload it to AWS's Key Management Service, and then configure that through it, and then it starts working seamlessly. When you're building a production system for RAG, Pinecone gives you the vector search, but you still have a lot of pieces that have to come with it, including embeddings, chunking, pre-processing the query, and security. Pinecone doesn't provide that out of the box. AWS has the infrastructure for it. When you're using Bedrock with Pinecone, it becomes a good combination because Bedrock itself is free. They only ask you to pay for the model invocations.

Pinecone is flexible. They give you a bunch of options. One of the good features is that they also provide embeddings within Pinecone, which is a neat feature. You can essentially choose your embedding sizes and things like that. So you do have some control over it. It's easy to set up, and we felt like it's not that expensive for us in comparison to serverless. That's why we took it.

If Pinecone gave us RAG as a service, we'd be more than happy to use that. Then we wouldn't have to go to something like AWS again.

We've been using Pinecone for a little over four months.

So far we haven't scaled it to that extent. We're just building a beta version of it. For the beta version, at least so far, it's been good. We're demoing this to a few people, and then we'll possibly scale up if needed. But so far, it's looking good.

We've rolled out the early version as a beta access to a few, maybe twenty to thirty customers. So far, there haven't been that many complaints, but also it hasn't been really stress-tested for say, ten thousand requests per minute or something like that. We haven't really put it to the test. But for these demos for our clients to use, it's working fine so far.

I have not personally engaged with customer service, as there are people above me who are making those decisions. I work as a developer and am just integrating everything. I haven't needed support because the documentation is good enough to help developers get up to speed.

The documentation is great. Plus, they have a chatbot that can help you answer all the questions about documentation, which I find helpful. I would say it's even better than AWS's documentation because AWS's SDK documentation is just not as helpful.

We weren't really sure about Pinecone security, and that's why we're using AWS for it. AWS is going to handle that whole pipeline of security and making sure that everything is passing through correctly. Pinecone comes in at just one of the stages, where it has to either at inference give you the most similar vectors or store your embedded chunks into a vector database. It's just one small piece in this. Most of the heavy lifting is done by our back-end plus AWS.

We were also using S3 Vectors, but it's still in preview. They haven't released it for all regions. It works in the US East, but in Europe West, it's not live yet. So we weren't able to go ahead with S3 Vectors. Pinecone was available though, and that's what we're using right now.

We're using Pinecone as a vector database over OpenSearch.

As a standalone vector database, I think Pinecone gets the job done. I would give it an eight out of ten. Overall, I rate this product an eight.

My main use case for Pinecone is making chatbots for custom solutions, and I use it as a primary vector database for my AI-powered chatbots.

Pinecone fits into my chatbot solutions by storing customer-related knowledge bases completely in vectors.

I have a few additional insights about my main use case or how Pinecone helps my chatbot solutions. It is a low-latency database, and while industry-high standard vector database options are available, Pinecone is a bit expensive.

I find Pinecone offers great features such as low latency and industry standards, which I find valuable. I also appreciate the simplicity of Pinecone that allows installation in our terminals to start coding. I can ingest my files through curl methods directly from my terminal into Pinecone.

I find Pinecone very good at scalability. I have handled over 100 gigabytes of data previously for different customers of mine.

Pinecone has positively impacted my organization. Compared to any other vector databases, it is a little ahead due to its latency, scalability, and robust architecture.

I have not seen a specific outcome or metric of reduced costs since I started using Pinecone because it is very expensive compared to any other vector databases.

I think Pinecone can be improved by potentially reducing some costs.

There are no other improvements needed for Pinecone that I have not mentioned, except for the cost.

I have been working in my current field for about four years until now.

Pinecone is stable.

Regarding scalability, I find Pinecone very good at it. I have handled over 100 gigabytes of data previously for different customers of mine.

Pinecone's scalability is fine, and I would rate it up to eight out of 10.

Previously, I switched to Qdrant for just testing it out and tried Weaviate. I felt Pinecone was doing better, but I had to switch to Qdrant because of the expensive pricing of Pinecone.

I have seen a return on investment. The efficiency of my bot has increased, and I might have spent about $50 a month, but the revenue I got was about 50 times greater than that.

My experience with the pricing, setup cost, and licensing of Pinecone is that it is a gray area. I would like them to work on the pricing.

Before choosing Pinecone, I did evaluate options such as Qdrant and Weaviate.

My advice to others looking into using Pinecone is to test it thoroughly in local environments and then push everything into Pinecone for production because Pinecone is a bit pricey.

My main use case with Pinecone involved building a RAG application where we used it for indexing. In our RAG application using Pinecone for indexing, we convert whatever text chunks are coming in into vector embeddings, which might be of different dimensions. We store these embeddings in Pinecone, and at query time, we perform a nearest neighbor search to find the most relevant text. For example, if you're asking a question about the different OPD expenses, then the embeddings most semantically similar to OPD expenses will come up. It's used for similarity search on text.

The best features that Pinecone offers include the separation via namespaces, which was really good. Another feature is the ability to deploy within different cloud servers of our choice, which was also advantageous, along with the out-of-the-box option that allows you to just use an API key and start using it without needing to set up anything.

Out of the features I mentioned, the most valuable in my workflow is the easy setup because it helps in prototyping easily. There can be different RAG use cases, and for each of these use cases, you just do not have to install a vector database or go through all of that; you can just use the API key.

Pinecone has positively impacted our organization by helping us to land a few clients or at least give a demo of how our application works, becoming a part of the solution we developed.

Pinecone can be improved by having the ability to have multi-modal embeddings out of the box as a good idea. A major reason we did not use Pinecone is that the serverless region was only in the United States; if it were available in India with serverless out-of-the-box implementation, we would have definitely used Pinecone.

Regarding needed improvements, I would like to see more regional endpoints, particularly serverless regional endpoints, as that's the most important one, along with multi-modality support.

I used the solution for about three to six months.

Pinecone is stable in my experience.

Pinecone is highly scalable compared to others, and it's out-of-the-box, although the drawback is the pricing.

Regarding how we set things up with Pinecone, we created different namespaces and within these namespaces, we created the embeddings for different catalogs.

We currently use PG vector with Postgres; it's not something I previously used, but it's beneficial because it operates on disk rather than in memory, which saves a lot of money.

Before choosing Pinecone, I evaluated options including PG vector with Postgres, Qdrant, and Milvus.

My advice for others looking into using Pinecone is to optimize all the embeddings before using it because if you are using it in a highly scalable manner, the pricing can get very high, so you have to be careful.

Pinecone was one of the earliest vector databases I came to know about, and it's the go-to option; I suggest it for anyone new to or learning about vector databases because it's very easy to start and work with without needing complex setups.

For future interviews, before asking deep questions, it's good to clarify things first because there is focus on cloud deployments, but we did not dive deeply into that; we only used Pinecone during the proof of concept and had to switch back due to data residency issues. I rate this product an 8 out of 10.

The main use case for Pinecone is to build RAG applications, but I have also built an image search engine on Pinecone by storing image embeddings and searching those image embeddings on it.

The first important thing about Pinecone is that it's a managed vector database, so there is no DevOps involved; it handles scaling, backups, replicas, and other infrastructure concerns, which is really helpful to me.

The best outcome of using Pinecone is that we don't have to manage one more application or one more thing in the overall application architecture because the vector database is the heart of any AI agent. When it's on Pinecone, we are safe and we don't have to worry about it; we can just use it via API and that's done.

In terms of time saved with Pinecone, it's really a time-saving solution because we don't have to manage the infrastructure. It streamlines our workflow and helps us create a proof of concept much faster because it becomes very easy to interact with Pinecone. It's really helpful, time-saving, and a faster way to build AI applications.

Pinecone has capabilities way beyond RAG applications because it can be used for recommendation systems, image similarity, and audio similarity as well, so it would be best if they could market those capabilities as well.

If Pinecone could increase the free quota and not kill the free quota after seven days, that would be great.

I have been using Pinecone for three years and have been building RAG applications on top of it.

Pinecone is very stable.

Pinecone scales well.

I have not needed the customer support for Pinecone yet.

We were using a file-based vector database, but as I mentioned, it's not a good solution beyond a proof of concept. When scaling beyond proof of concept, it's not a viable solution, so we were forced to switch to a platform, and we found Pinecone very easy to use.

The pricing for Pinecone is fair, and setup is really easy. You just give an index name and a couple of other things such as the dimension you want to have, and then you are good to go with no hassle.

As I mentioned earlier, time is saved with Pinecone. Money-wise, I'm not certain, but on the employee side, fewer employees are needed. DevOps is relieved because they don't have to manage a vector database and security and all the things related to the vector database.

We evaluated Quadrant, but the managed version of Quadrant is not as robust as Pinecone, so we moved to Pinecone.

If I want to use any file-based vector database, it becomes really not possible to use because it cannot scale. You cannot connect or create multiple replicas on top of a single file-based vector database. In the context of managed instances, Pinecone comes to us very easily and it becomes very easy to scale workers on top of Pinecone.

Pinecone is a great platform; it's easy to use with clean SDKs, so it becomes always a go-to option when I think of a vector database.

One piece of advice I would like to give about Pinecone is to make sure you first clearly discuss what embedding size you want because it's not possible to change the embedding size after setup.

I would rate this review a ten out of ten.

My main use case for Pinecone is creating vector indexes for GenAI applications.

A specific example of how I use Pinecone in one of my projects is utilizing a RAG pipeline where I take text from PDF documents, convert those into chunks, ingest those into the Pinecone vector database, and then have a frontend UI that uses LLMs to query the vector database and retrieve answers.

What I appreciate about Pinecone is that it provides reranking and other features, and it's a SaaS-based solution that is serverless.

Pinecone's reranking aspect works by taking a list of documents from the indexes and organizing them based on the ranking that is relevant to the question being asked by the user, ensuring that if reranking is applied, the user gets the most relevant answers as LLMs understand them, providing near-perfect answers versus when not using reranking, where the LLM takes all output from the vector index, which won't be quite that perfect.

Pinecone's serverless aspect is valuable because I don't have to manage the infrastructure myself, as Pinecone takes care of that.

Pinecone has positively impacted my organization by helping people in needle-in-a-haystack situations, as previously they had to grind through PDF documents, PowerPoint documents, and websites, but now with Pinecone, they can ask questions and receive references to documents along with the page numbers where that information exists, so they can use it as a reference or backtrack, especially for things such as FDA approvals where they can quote the exact page number from PDF documents, eliminating hallucination and providing real-time data that relies on an external vector database with enough guardrails to ensure it won't provide information not in the vector database, confining it to the information present in the indexes.

Pinecone has helped full-time employees rely less on contractors to find information, enabling them to access data at their fingertips and reducing the turnaround time to generate reports.

I give Pinecone a nine out of ten because I hope it provides an end-to-end agentic solution, but currently, it doesn't have those agentic capabilities, meaning I have to create a Streamlit application and manage it to communicate with Pinecone. If Pinecone could provide those kinds of web apps out of the box, I would give it a perfect ten.

Nothing else is needed since Pinecone provides APIs for integration, making it not a hurdle, and I am happy with what I have.

Pinecone is good as it is, but had it been on AWS infrastructure, we wouldn't experience some network lags because it's outside AWS. However, when we started two years ago, there weren't any vector databases on AWS, making Pinecone a pioneer in the field.

I have been using Pinecone for the last two years.

Pinecone is stable.

Pinecone is scalable.

I have not needed customer support yet, as everything works seamlessly.

There was no solution before Pinecone, as the vector database gained traction about two years ago, and Pinecone were the pioneers in this field, which is why we picked them.

I have seen a return on investment with Pinecone, as the application we built received positive feedback from internal stakeholders about how much it's helping them make business decisions and access information quickly at their fingertips.

The experience with pricing, setup cost, and licensing for Pinecone is not in my area, as I am a developer who uses the tools.

No other options were evaluated before choosing Pinecone.

Pinecone perfectly fits my organization's needs based on our use case. The market for vector databases is broad right now, offering many options; however, I don't have experience with other tools and technologies. I would give Pinecone a rating of nine out of ten overall.