https:\/\/uplatz.com\/course-details\/ai-ethics-governance-and-compliance\/571<\/a><\/p>\n1.1 Defining the Vector Database: Beyond Rows and Columns<\/b><\/h4>\n
A vector database, also known as a vector store or vector search engine, is a specialized database system designed to efficiently store, index, manage, and query high-dimensional vector embeddings.<\/span>1<\/span> Unlike traditional relational databases that organize structured data into predefined rows and columns, or NoSQL databases that handle semi-structured data like JSON documents, a vector database operates on a fundamentally different data type: the vector.<\/span>4<\/span> These vectors are numerical representations of complex, often unstructured, data such as text, images, audio, or even abstract concepts like user preferences.<\/span>1<\/span><\/p>\nThe core purpose of a vector database is to enable similarity search.<\/span>9<\/span> Instead of retrieving data based on exact matches to keywords or filtering on explicit field values\u2014the domain of traditional query languages like SQL\u2014a vector database finds data based on its conceptual or semantic similarity to a query.<\/span>3<\/span> This paradigm shift allows for powerful new ways of interacting with information. For instance, a query for the term “smartphone” might retrieve documents containing the words “cellphone” or “mobile device,” not because of a predefined synonym list, but because the vector representations of these concepts are mathematically close to one another in a high-dimensional space.<\/span>3<\/span> This ability to search based on what data<\/span><\/p>\nmeans<\/span><\/i>, rather than merely what it <\/span>contains<\/span><\/i>, is the defining characteristic and primary value proposition of vector databases.<\/span><\/p>\n <\/p>\n
1.2 The Challenge of Unstructured Data<\/b><\/h4>\n
<\/p>\n
The necessity for this new database paradigm is rooted in the changing nature of data itself. A vast and rapidly expanding portion of the world’s data is unstructured\u2014a category that includes everything from social media posts and text documents to images, videos, and audio clips.<\/span>3<\/span> This type of data is growing at an estimated rate of 30% to 60% annually and poses a significant challenge for conventional data management systems.<\/span>3<\/span><\/p>\nTraditional databases, both SQL and many NoSQL variants, are ill-equipped to handle the richness and ambiguity of unstructured content. Relational databases demand that data conform to a rigid, predefined schema, making it difficult to store and analyze fluid data types like natural language or images.<\/span>3<\/span> While they can store a file path to an image, they possess no native capability to understand the image’s content. Querying for “a photograph of a red car at sunset” is an impossible task for a standard SQL database without extensive and manually curated metadata (tags). Similarly, keyword-based search systems fall short because they fail to capture context, nuance, and semantic relationships.<\/span>12<\/span> They can find documents containing the exact word “king,” but they cannot inherently understand its relationship to “queen,” “monarch,” or “ruler.” The process of loading, managing, and preparing this unstructured data for AI applications using traditional databases is a labor-intensive and often inadequate endeavor.<\/span>3<\/span><\/p>\n <\/p>\n
1.3 Vector Embeddings: Translating the World into Numbers<\/b><\/h4>\n
<\/p>\n
Vector databases solve the unstructured data problem through the transformative concept of vector embeddings. These embeddings serve as a universal translator, converting complex, non-numeric data into a mathematical format that computers can process and compare.<\/span><\/p>\nWhat are Vector Embeddings?<\/span><\/p>\nA vector embedding is a dense numerical representation of a data object, typically in the form of an array of floating-point numbers.8 While a simple vector can be visualized as a list of numbers, such as<\/span><\/p>\n{12, 13, 19, 8, 9} <\/span>9<\/span>, the embeddings used in modern AI are far more complex, consisting of hundreds or even thousands of dimensions.<\/span>2<\/span> These embeddings are not created manually; they are the output of sophisticated machine learning models, particularly deep learning neural networks, that have been trained on vast datasets.<\/span>9<\/span><\/p>\nThe Concept of High-Dimensional Space<\/span><\/p>\nEach number in a vector corresponds to a coordinate along a specific dimension in a high-dimensional vector space. These dimensions are not arbitrary; they represent “latent features” of the data\u2014abstract, underlying characteristics that the model has learned to recognize from patterns in the training data.2 For an image, these latent features might correspond to textures, shapes, color palettes, or object compositions. For text, they might represent grammatical structure, tone, or semantic concepts.<\/span><\/p>\nThe position of a vector within this multi-dimensional space encapsulates its meaning. This leads to the most crucial principle of the vector paradigm: <\/span>semantic similarity is represented by spatial proximity<\/b>.<\/span>1<\/span> Data objects with similar meanings will have their corresponding vectors located close to one another in this space. For example, the vectors for the words “cat” and “dog” will be closer to each other than they are to the vector for the word “car,” effectively transforming a linguistic or conceptual problem into a geometric one that can be solved with mathematical distance calculations.<\/span>16<\/span> This abstraction is incredibly powerful. It creates a universal, mathematical language for meaning, allowing for novel applications like multi-modal search\u2014for instance, using an image query to find semantically related text passages.<\/span>2<\/span> The database itself becomes a unified space where concepts from entirely different domains can be compared and related, a capability fundamentally impossible with traditional database architectures.<\/span><\/p>\nHow Embeddings are Created<\/span><\/p>\nThe generation of high-quality embeddings is a critical prerequisite for any vector database application. The process relies on pre-trained deep learning models tailored to specific data modalities:<\/span><\/p>\n\n- Text (Word, Sentence, and Document Embeddings):<\/b> Natural Language Processing (NLP) models like Word2Vec, GloVe, BERT, and the Universal Sentence Encoder (USE) are trained on massive text corpora (like the entirety of Wikipedia and large book collections). Through this training, they learn the intricate contextual relationships between words, phrases, and sentences, encoding this understanding into dense vector representations.<\/span>13<\/span><\/li>\n
- Images and Videos:<\/b> In computer vision, models such as Convolutional Neural Networks (CNNs) like ResNet and VGG, or more recent Vision Transformers (ViT), are used. These models are trained to identify and extract feature vectors that represent the visual content of an image, including shapes, colors, textures, and the objects present.<\/span>13<\/span><\/li>\n
- Other Data Types (Users, Products, Audio):<\/b> The concept of embeddings extends beyond text and images. Abstract entities can also be vectorized. For example, a user’s behavior on a platform (clicks, purchases, viewing history) can be transformed into a “user embedding,” while a product’s attributes and features can be represented by a “product embedding.” Placing these in the same vector space allows recommendation systems to match users with products they are likely to enjoy.<\/span>13<\/span><\/li>\n<\/ul>\n
It is important to recognize that the individual numbers within a vector are not directly interpretable by humans. Their meaning is derived from their collective values and their relationships with the other numbers in the vector.<\/span>13<\/span> The quality of search and analysis performed by a vector database is therefore entirely contingent on the quality of the embeddings it stores. An embedding model that is poorly suited or inadequately trained for a specific domain will produce vectors that do not accurately map semantic similarity to spatial proximity, leading to irrelevant and poor-quality search results. This establishes a “garbage in, garbage out” principle for semantics. Consequently, a vector database is not a standalone solution but a critical component within a larger AI pipeline. A successful implementation requires a coherent embedding strategy, which includes selecting an appropriate model, potentially fine-tuning it on domain-specific data, and establishing a robust process for updating embeddings when the model or source data changes.<\/span>18<\/span> This deep dependency on the external embedding model is a key operational consideration that distinguishes vector databases from their traditional counterparts.<\/span><\/p>\n <\/p>\n
Part II: The Mechanics of Similarity Search<\/b><\/h2>\n
<\/p>\n
Understanding what a vector database is requires delving into how it works. The ability to perform near-instantaneous similarity searches across billions of high-dimensional vectors is not a trivial feat. It is enabled by a sophisticated architecture and a class of specialized algorithms that solve the inherent challenges of operating in high-dimensional spaces.<\/span><\/p>\n <\/p>\n
Section 2: Architectural Blueprint of a Vector Database<\/b><\/h3>\n
<\/p>\n
The operation of a vector database can be conceptualized as a four-stage pipeline, from the creation of vectors to the delivery of refined search results.<\/span>20<\/span><\/p>\n <\/p>\n
2.1 The Core Workflow: A Four-Stage Pipeline<\/b><\/h4>\n
<\/p>\n
\n- Stage 1: Vectorization:<\/b> This initial stage involves the conversion of raw, unstructured data into vector embeddings. As detailed previously, this is accomplished using a machine learning model appropriate for the data type (e.g., a text embedding model for documents, an image embedding model for pictures). This process typically occurs outside the vector database itself. The application generates the vectors and then “inserts” or “upserts” them into the database, often along with a reference to the original data and any relevant metadata.<\/span>9<\/span><\/li>\n
- Stage 2: Indexing:<\/b> This is the most critical stage for achieving high performance. A naive, brute-force search that compares a query vector to every other vector in a large dataset is computationally prohibitive due to a phenomenon known as the “curse of dimensionality”.<\/span>2<\/span> To overcome this, vector databases create specialized index structures. These indexes are data structures that organize the vectors in a way that dramatically prunes the search space. For example, an index might group spatially close vectors into clusters or build a graph connecting neighboring vectors.<\/span>1<\/span> The fundamental goal of indexing is to allow the search algorithm to quickly discard vast regions of the vector space that are irrelevant to the query, thereby avoiding the need to perform a distance calculation for every single vector in the database.<\/span><\/li>\n
- Stage 3: Querying:<\/b> When a user submits a query (e.g., a search term, a sentence, or an image), it is first passed through the <\/span>exact same<\/span><\/i> embedding model that was used to create the vectors in the database.<\/span>9<\/span> This produces a query vector. The database then uses its specialized index to efficiently find the<\/span>
\n<\/span>$k$ vectors in its collection that are “closest” to this query vector. The value of $k$ is specified by the user (e.g., “find the top 10 most similar items”). The definition of “closest” is determined by a mathematical distance metric chosen for the index.<\/span>1<\/span><\/li>\n- Stage 4: Post-processing and Filtering:<\/b> The initial set of $k$ nearest neighbors retrieved from the index is a list of candidates. This list can be further refined in a final step. Post-processing can involve re-ranking the candidates using a more computationally expensive but precise distance calculation to improve the ordering of the final results. More importantly, this stage often involves applying filters based on metadata stored alongside the vectors.<\/span>1<\/span> For example, a query for “similar shirts” could be filtered to only include items that are in stock, under a certain price, and available in a specific size. This ability to combine semantic similarity search with traditional structured filtering is a crucial feature for real-world applications.<\/span>24<\/span><\/li>\n<\/ol>\n
<\/p>\n
2.2 Measuring Closeness: The Mathematics of Similarity<\/b><\/h4>\n
<\/p>\n
The concept of “closeness” or “similarity” in a vector space is not subjective; it is quantified using precise mathematical formulas known as distance metrics or similarity measures. The choice of metric is critical and is often determined by the properties of the embedding model used.<\/span>1<\/span> The three most common metrics are:<\/span><\/p>\n\n- Cosine Similarity:<\/b> This metric measures the cosine of the angle between two vectors. It is not concerned with the magnitude (or length) of the vectors but only their direction. Its output ranges from -1 (indicating the vectors point in opposite directions) to 0 (indicating they are orthogonal) to 1 (indicating they point in the exact same direction). Because semantic meaning in many text-based embedding models is encoded in the direction of the vector, cosine similarity is the de facto standard for NLP tasks and semantic search.<\/span>20<\/span><\/li>\n
- Euclidean Distance (L2 Distance):<\/b> This is the most intuitive distance measure. It calculates the straight-line or “as the crow flies” distance between the endpoints of two vectors in the multi-dimensional space. The formula is a generalization of the Pythagorean theorem: $d(v_1, v_2) = \\sqrt{\\sum_{i=1}^{n}(v_{1i} – v_{2i})^2}$. A smaller Euclidean distance signifies greater similarity. It is widely used in computer vision and other domains where the magnitude of the vector’s components is meaningful.<\/span>1<\/span><\/li>\n
- Dot Product:<\/b> The dot product calculates the product of the two vectors’ magnitudes and the cosine of the angle between them. Its value ranges from negative infinity to positive infinity. Unlike cosine similarity, it is sensitive to both the direction and the magnitude of the vectors. A larger positive value indicates greater similarity.<\/span>20<\/span><\/li>\n<\/ul>\n
<\/p>\n
2.3 The Search Dilemma: Exact (k-NN) vs. Approximate (ANN) Search<\/b><\/h4>\n
<\/p>\n
At the heart of vector database design is a fundamental trade-off between search accuracy and performance. This trade-off manifests in the choice between two approaches to nearest neighbor search.<\/span><\/p>\n\n- k-Nearest Neighbors (k-NN):<\/b> This is the “exact” or “brute-force” method of finding the $k$ nearest neighbors to a query vector. It works by exhaustively calculating the distance between the query vector and every single other vector in the dataset. It then sorts these distances and returns the top $k$ results.<\/span>1<\/span> This method guarantees 100% accuracy\u2014it will always find the true nearest neighbors. However, its computational complexity is linear,<\/span>
\n<\/span>$O(N \\cdot D)$, where $N$ is the number of vectors and $D$ is their dimensionality. For datasets containing millions or billions of vectors, this approach is far too slow and resource-intensive for any real-time application.<\/span>23<\/span><\/li>\n- Approximate Nearest Neighbor (ANN):<\/b> This is the set of techniques that makes large-scale, low-latency vector search possible.<\/span>2<\/span> ANN algorithms make a pragmatic trade-off: they sacrifice a small, often negligible, amount of accuracy in exchange for a massive improvement in search speed.<\/span>23<\/span> Instead of exhaustively checking every vector, ANN algorithms use the clever indexing structures mentioned earlier to intelligently navigate the vector space and quickly identify a region of highly probable candidates. The core insight behind ANN is that for most applications\u2014such as product recommendations or semantic search\u2014finding an item that is “99% similar” is functionally just as good as finding the one that is “100% similar,” especially if the former can be done in milliseconds and the latter would take seconds or minutes.<\/span>29<\/span><\/li>\n<\/ul>\n
The “curse of dimensionality” makes exact `k-NN search computationally intractable for the very data\u2014high-dimensional vectors\u2014that these databases are designed to manage.<\/span>2<\/span> Therefore, the adoption of ANN is not merely an optional optimization; it is a fundamental necessity for any vector database system to be viable at a meaningful scale. In practice, the term “vector search” is almost always synonymous with “approximate vector search.” This implies that every developer and user of a vector database must, either implicitly or explicitly, engage with this trade-off between speed and accuracy. Mastering this balance, often by selecting a specific ANN algorithm and tuning its parameters, is a core competency for engineers building applications on top of these systems.<\/span>23<\/span><\/p>\n <\/p>\n
Section 3: A Deep Dive into Approximate Nearest Neighbor (ANN) Algorithms<\/b><\/h3>\n
<\/p>\n
The power and efficiency of a vector database are largely determined by its choice of ANN indexing algorithm. These algorithms are the engines that drive fast similarity search. They can be broadly categorized into four families, each with its own mechanism, performance characteristics, and trade-offs.<\/span>2<\/span><\/p>\n <\/p>\n
3.1 Graph-Based Methods (e.g., HNSW)<\/b><\/h4>\n
<\/p>\n
Mechanism:<\/b> Hierarchical Navigable Small World (HNSW) is currently one of the most popular and highest-performing ANN algorithms. It constructs a sophisticated, multi-layered graph structure. In this graph, each node represents a vector from the dataset. Edges connect nodes that are close to each other in the vector space. The graph is hierarchical: the top layers contain sparse, long-range connections that link distant clusters, while the lower, denser layers contain short-range connections that link close neighbors within a cluster.<\/span>10<\/span><\/p>\nSearch Process:<\/b> A search begins at a designated entry point in the sparsest top layer. The algorithm then greedily traverses the graph, always moving from the current node to the connected neighbor that is closest to the query vector. When it reaches a local minimum in that layer (a point from which no connected neighbor is closer to the query), it drops down to the next, denser layer and resumes the greedy search. This process repeats, progressively refining the search with greater precision, until it reaches the bottom-most layer, which contains the most detailed connections. The path taken provides a set of high-quality candidates for the nearest neighbors.<\/span>10<\/span><\/p>\nTrade-offs:<\/b> HNSW is renowned for its excellent balance of high search speed and high recall (a measure of accuracy). However, this performance comes at the cost of higher memory consumption, as the entire graph structure, with all its nodes and edges, must be stored in RAM.<\/span>31<\/span> The index build time can also be significant for large datasets.<\/span><\/p>\n <\/p>\n
3.2 Hashing-Based Methods (e.g., LSH)<\/b><\/h4>\n
<\/p>\n
Mechanism:<\/b> Locality-Sensitive Hashing (LSH) is a family of algorithms based on a clever hashing principle. It employs a set of hash functions specifically designed such that similar input vectors have a high probability of colliding\u2014that is, being mapped to the same “hash bucket.” Dissimilar vectors, conversely, are likely to be mapped to different buckets.<\/span>2<\/span><\/p>\nSearch Process:<\/b> To find approximate neighbors for a query vector, the system first applies the same LSH functions to the query vector to determine which bucket(s) it falls into. The search is then restricted to only those vectors that reside in the same bucket(s). This dramatically reduces the number of distance comparisons required, as the vast majority of vectors in other buckets are ignored.<\/span><\/p>\nTrade-offs:<\/b> LSH is extremely fast and generally more memory-efficient than graph-based methods, making it a viable option for massive datasets. However, it often provides lower recall (accuracy) than HNSW and can be very sensitive to the choice of hash functions and other tuning parameters. It represents a choice that heavily prioritizes speed and scalability over precision.<\/span>23<\/span><\/p>\n <\/p>\n
3.3 Tree-Based Methods (e.g., ANNOY)<\/b><\/h4>\n
<\/p>\n
Mechanism:<\/b> ANNOY (Approximate Nearest Neighbors Oh Yeah), an algorithm developed by Spotify, is a prominent example of a tree-based approach. It works by building a forest of multiple random binary trees. To build a single tree, the entire vector space is recursively partitioned by randomly chosen hyperplanes. At each step, the space is split in two, and the vectors are divided between the two resulting subspaces. This process continues until the leaf nodes of the tree contain only a small number of vectors.<\/span>23<\/span><\/p>\nSearch Process:<\/b> A search involves traversing all the trees in the forest simultaneously. A priority queue is used to keep track of the most promising branches to explore across all trees. By exploring multiple, randomly partitioned trees, the algorithm increases the probability of finding the true nearest neighbors. The vectors collected from the leaf nodes visited during the traversal form the candidate set.<\/span><\/p>\nTrade-offs:<\/b> Tree-based methods like ANNOY are relatively simple to implement and are quite memory-efficient. However, their performance can degrade, particularly in terms of accuracy, when dealing with very high-dimensional vectors, a common scenario in modern AI applications.<\/span>31<\/span><\/p>\n <\/p>\n
3.4 Compression-Based Methods (e.g., PQ, SQ)<\/b><\/h4>\n
<\/p>\n
Mechanism:<\/b> This family of algorithms tackles the performance and memory problem not by reducing the search space, but by reducing the size of the vectors themselves.<\/span><\/p>\n\n- Product Quantization (PQ):<\/b> This sophisticated technique achieves high rates of compression. It first splits each high-dimensional vector into a number of smaller, lower-dimensional segments. Then, it runs a clustering algorithm (like `k-means) on the set of all segments in the dataset to generate a “codebook” of representative centroids for each segment position. Finally, each vector segment in the original dataset is replaced by the ID of its closest centroid from the corresponding codebook. This transforms a vector of high-precision floating-point numbers into a much shorter vector of low-bit integer IDs, dramatically compressing its size.<\/span>2<\/span><\/li>\n
- Scalar Quantization (SQ):<\/b> This is a simpler compression method. It reduces vector size by converting each numerical component from a high-precision format (e.g., a 32-bit float) to a lower-precision one (e.g., an 8-bit integer). This mapping of a continuous range of values to a smaller, discrete set of values reduces the memory required to store each vector.<\/span>31<\/span><\/li>\n<\/ul>\n
Search Process:<\/b> Distance calculations are performed using these compressed vector representations, which is significantly faster and requires far less memory than operating on the full-precision, full-dimensional vectors.<\/span><\/p>\nTrade-offs:<\/b> The primary benefit of these methods is a massive reduction in memory footprint, which can allow gigantic indexes that would otherwise require terabytes of storage to fit into RAM. This is a critical advantage for cost and performance. The major drawback is that the compression is inherently lossy, meaning information is lost. This can lead to a reduction in search accuracy. For this reason, quantization techniques are often used in combination with other indexing methods, such as IVF, creating composite indexes like IVF-PQ that balance scalability, speed, and accuracy.<\/span>31<\/span><\/p>\n <\/p>\n
\n\n\n| Algorithm<\/span><\/td>\n | Mechanism Summary<\/span><\/td>\n | Search Speed<\/span><\/td>\n | Accuracy (Recall)<\/span><\/td>\n | Memory Usage<\/span><\/td>\n | Index Build Time<\/span><\/td>\n | Key Strengths<\/span><\/td>\n | Key Weaknesses<\/span><\/td>\n<\/tr>\n\n| HNSW<\/b><\/td>\n | Builds a multi-layered navigable graph of vectors.<\/span><\/td>\n | Very High<\/span><\/td>\n | Very High<\/span><\/td>\n | High<\/span><\/td>\n | Moderate to High<\/span><\/td>\n | State-of-the-art speed\/recall balance.<\/span><\/td>\n | High memory consumption.<\/span><\/td>\n<\/tr>\n\n| LSH<\/b><\/td>\n | Hashes similar vectors into the same “buckets”.<\/span><\/td>\n | Very High<\/span><\/td>\n | Low to Moderate<\/span><\/td>\n | Low<\/span><\/td>\n | Low<\/span><\/td>\n | Extremely scalable and memory-efficient.<\/span><\/td>\n | Lower accuracy, sensitive to tuning.<\/span><\/td>\n<\/tr>\n\n| ANNOY<\/b><\/td>\n | Builds a forest of random projection binary trees.<\/span><\/td>\n | High<\/span><\/td>\n | Moderate<\/span><\/td>\n | Low to Moderate<\/span><\/td>\n | Low<\/span><\/td>\n | Simple, memory-efficient, good for moderate dimensions.<\/span><\/td>\n | Performance degrades in very high dimensions.<\/span><\/td>\n<\/tr>\n\n| PQ \/ SQ<\/b><\/td>\n | Compresses vectors by quantizing their values.<\/span><\/td>\n | High<\/span><\/td>\n | Moderate<\/span><\/td>\n | Very Low<\/span><\/td>\n | Moderate<\/span><\/td>\n | Massive memory savings, enabling in-RAM indexes.<\/span><\/td>\n | Lossy compression reduces accuracy.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n A notable trend in the evolution of vector databases is the increasing importance of combining vector similarity search with traditional metadata filtering. Real-world applications rarely involve a pure semantic search. More often, a user wants to find semantically similar items that also meet specific structured criteria (e.g., “laptops similar to this one, but with more than 16 GB of RAM and under $1,500”). Early vector databases handled this with inefficient multi-step processes: “pre-filtering,” which filters the dataset by metadata first and then performs a vector search on the much smaller subset, or “post-filtering,” which performs a vector search first and then filters the candidate results.<\/span>20<\/span> Pre-filtering can be slow if the metadata filter is not very selective, while post-filtering can be inaccurate if the true nearest neighbors are filtered out. The development of more advanced “single-stage” or “hybrid” filtering techniques, which integrate metadata constraints directly into the ANN search process, is a key area of innovation and a significant differentiator among modern vector database providers.<\/span>24<\/span> This capability is becoming a critical feature for enterprise readiness, as it directly addresses the complex, hybrid nature of real-world queries.<\/span><\/p>\n <\/p>\n Part III: The Evolving Database Landscape<\/b><\/h2>\n <\/p>\n Vector databases did not emerge in a vacuum. They represent the latest evolutionary step in a long history of data management systems. To fully appreciate their role and significance, it is essential to compare them to the established paradigms of relational (SQL) and NoSQL databases and to understand the market trends that are blurring the lines between these categories.<\/span><\/p>\n <\/p>\n Section 4: A Comparative Analysis: Vector vs. Relational (SQL) and NoSQL Databases<\/b><\/h3>\n <\/p>\n The choice of a database is one of the most fundamental architectural decisions in software development. Vector, SQL, and NoSQL databases are designed with different philosophies, optimized for different data types, and excel at different tasks.<\/span><\/p>\n <\/p>\n \n\n\n| Key Attribute<\/span><\/td>\n | Relational (SQL)<\/span><\/td>\n | NoSQL<\/span><\/td>\n | Vector<\/span><\/td>\n<\/tr>\n\n | | | | | | |
![\"\"](\"https:\/\/uplatz.com\/blog\/wp-content\/uploads\/2025\/06\/Blog-images-new-set-A-5-2.png\")
<\/p>\n