{"id":780,"date":"2026-04-06T04:27:17","date_gmt":"2026-04-06T04:27:17","guid":{"rendered":"https:\/\/techpaathshala.com\/blog\/?p=780"},"modified":"2026-04-21T06:52:16","modified_gmt":"2026-04-21T06:52:16","slug":"what-is-rag-and-why-every-developer-should-know-it-in-2026","status":"publish","type":"post","link":"https:\/\/techpaathshala.com\/blog\/what-is-rag-and-why-every-developer-should-know-it-in-2026\/","title":{"rendered":"What is RAG and Why Every Developer Should Know It in 2026"},"content":{"rendered":"\n

Imagine you hire a brilliant new employee. They have an MBA from a top institution, can write flawlessly, reason through complex problems, and communicate with confidence. You are impressed.<\/p>\n\n\n\n

Then, on their first day, you ask them a simple question: “What does our refund policy say?”<\/p>\n\n\n\n

They pause. Think. Then confidently give you an answer \u2014 except it is completely wrong. Not because they are unintelligent, but because nobody gave them the employee handbook. They answered based on what a typical refund policy looks like at a typical company. Not yours.<\/p>\n\n\n\n

This is, almost exactly, what happens when you build an AI feature using a large language model without RAG.<\/p>\n\n\n\n

The model is brilliant. It has been trained on a vast amount of human knowledge. But it knows nothing about your<\/em> company, your<\/em> product, your<\/em> documentation, or your<\/em> data. When asked about any of these things, it does what that new employee did \u2014 it fills the gap with a plausible-sounding answer drawn from general knowledge. And in production, that plausible-sounding wrong answer is a serious problem.<\/p>\n\n\n\n

RAG \u2014 Retrieval-Augmented Generation \u2014 is the employee handbook.<\/strong><\/p>\n\n\n\n

It is the pattern that gives an AI model access to the specific, accurate, up-to-date information it needs to answer questions correctly. And in 2026, it is one of the most important concepts in applied AI engineering \u2014 for beginners building their first AI feature, for mid-level developers integrating LLMs into production apps, and for final-year students who want to enter the job market with skills that are immediately relevant.<\/p>\n\n\n\n

This guide explains what RAG is, why it exists, how it works, and how to start building with it.<\/p>\n\n\n

\"Advertisement\"<\/a><\/div>\n\n\n\n
\n\n\n\n

Why RAG Exists: The Problem It Solves<\/h2>\n\n\n\n

To understand RAG, you first need to understand the core limitation it was designed to address.<\/p>\n\n\n\n

Every large language model \u2014 GPT-4, Claude, Llama, Gemini \u2014 is trained on a massive dataset of text collected up to a specific point in time. After training, the model’s knowledge is fixed. It does not update itself when new information appears in the world. It does not learn about your product launch from last month. It does not know about the policy change your legal team made last week. It has no access to your internal documents, your customer database, or your proprietary knowledge.<\/p>\n\n\n\n

This creates two problems that show up in real AI applications:<\/p>\n\n\n\n

Problem 1: Knowledge cutoff.<\/strong> The model’s training data has a cutoff date. Ask it about events, products, or policies that emerged after that date, and it either says it does not know or \u2014 more dangerously \u2014 makes something up that sounds plausible.<\/p>\n\n\n\n

Problem 2: No proprietary knowledge.<\/strong> The model was not trained on your company’s data. It cannot answer questions about your specific product, your internal processes, your customer policies, or anything else that is unique to your organisation.<\/p>\n\n\n\n

Both problems share the same root cause: the model can only answer from what it already knows. And there are two ways to give it new knowledge.<\/p>\n\n\n\n

Option A: Fine-tuning.<\/strong> Retrain the model on your proprietary data so the new information becomes part of the model’s weights. This is expensive (significant compute cost), slow (days to weeks), requires ML expertise, and produces a static result \u2014 once the fine-tuned model is trained, it does not update automatically when your data changes. For most real-world applications, it is the wrong solution.<\/p>\n\n\n\n

Option B: RAG.<\/strong> At the moment a user asks a question, retrieve the relevant information from your knowledge base and give it to the model as context. The model uses that context \u2014 alongside its general intelligence \u2014 to produce a grounded, accurate answer. No retraining. No static knowledge. Your data updates independently, and the model always retrieves the current version.<\/p>\n\n\n\n

For the vast majority of production AI applications \u2014 chatbots, document Q&A, customer support, internal knowledge assistants, research tools \u2014 RAG is the right solution. It is faster to implement, cheaper to run, easier to update, and produces more accurate results than fine-tuning for knowledge-intensive tasks.<\/p>\n\n\n\n

\n\n\n\n

What is RAG in AI? The Core Concept Explained<\/h2>\n\n\n\n

RAG stands for Retrieval-Augmented Generation.<\/strong> Break it down word by word and the concept becomes self-explanatory:<\/p>\n\n\n\n

    \n
  • Retrieval<\/strong> \u2014 Finding and fetching relevant information from a knowledge base<\/li>\n\n\n\n
  • Augmented<\/strong> \u2014 Adding that information to the model’s context, augmenting what it knows<\/li>\n\n\n\n
  • Generation<\/strong> \u2014 The model generates its response using both its training knowledge and the retrieved context<\/li>\n<\/ul>\n\n\n\n

    The key insight is in the word “Augmented.” RAG does not replace the model’s intelligence. It supplements it with accurate, current, specific information at the moment it is needed.<\/p>\n\n\n\n

    The Simple Analogy<\/h3>\n\n\n\n

    Think of a RAG system as an open-book exam rather than a closed-book exam.<\/p>\n\n\n\n

    In a closed-book exam (standard LLM), the student \u2014 the model \u2014 answers entirely from memory. Smart students (powerful models) do well, but even the smartest student cannot recall information they were never taught. And memory is imperfect \u2014 details blur, facts get mixed up.<\/p>\n\n\n\n

    In an open-book exam (RAG), the student can look up information from their notes and reference materials before answering. The student still needs to be intelligent enough to find the right information and use it correctly. But the answer is grounded in actual source material rather than memory alone.<\/p>\n\n\n\n

    RAG gives your AI model its notes.<\/p>\n\n\n\n

    \n\n\n\n

    How RAG Works: The Technical Flow<\/h2>\n\n\n\n

    Understanding the mechanics of RAG is the key to being able to build with it. The process has two distinct phases \u2014 an offline preparation phase and a real-time query phase.<\/p>\n\n\n\n

    Phase 1: Offline \u2014 Building the Knowledge Base<\/h3>\n\n\n\n

    Before any user query is processed, you prepare your knowledge base. This is a one-time (and periodically updated) process that involves three steps.<\/p>\n\n\n\n

    Step 1: Document Ingestion<\/strong><\/p>\n\n\n\n

    You gather the documents, files, or data sources that contain the knowledge you want your AI to access. This could be:<\/p>\n\n\n\n

      \n
    • PDF files (product manuals, compliance documents, HR policies)<\/li>\n\n\n\n
    • Web pages (documentation, blog posts, help articles)<\/li>\n\n\n\n
    • Database records (product descriptions, customer FAQs, internal wikis)<\/li>\n\n\n\n
    • Text files, Notion pages, Google Docs \u2014 essentially any text-based content<\/li>\n<\/ul>\n\n\n\n

      Step 2: Chunking<\/strong><\/p>\n\n\n\n

      Large documents cannot be processed whole. They are broken into smaller, manageable pieces called chunks<\/strong>. A chunk is typically a paragraph, a section, or a fixed number of tokens (words).<\/p>\n\n\n\n

      Why does chunking matter? Because when a user asks a question, you want to retrieve the specific part<\/em> of a document that answers it \u2014 not the entire 40-page manual. Good chunking means better retrieval precision.<\/p>\n\n\n\n

      from langchain.text_splitter import RecursiveCharacterTextSplitter\n\nsplitter = RecursiveCharacterTextSplitter(\n    chunk_size=500,      # tokens per chunk\n    chunk_overlap=50     # overlap between adjacent chunks\n)\n\nchunks = splitter.split_documents(documents)\n<\/code><\/pre>\n\n\n\n
      Step 3: Embedding and Storing<\/strong><\/p>\n\n\n\n
      Each chunk is converted into a vector embedding<\/strong> \u2014 a numerical representation that captures the semantic meaning of the text. Similar meanings produce similar vectors, which is what makes semantic search possible.<\/p>\n\n\n\n
      These embeddings are stored in a vector database<\/strong> \u2014 a specialised database optimised for similarity search. Think of it as a library where books are organised by meaning rather than by title or alphabetically.<\/p>\n\n\n\n
      from langchain_openai import OpenAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\n\nembeddings = OpenAIEmbeddings(model=\"text-embedding-3-small\")\n\nvectorstore = PineconeVectorStore.from_documents(\n    documents=chunks,\n    embedding=embeddings,\n    index_name=\"my-knowledge-base\"\n)\n<\/code><\/pre>\n\n\n\n
      Your knowledge base is now ready. Every document has been processed, chunked, embedded, and stored. This phase runs once \u2014 and is re-run whenever your documents are updated.<\/p>\n\n\n\n
      \n\n\n\n
      Phase 2: Real-Time \u2014 Answering a User Query<\/h3>\n\n\n\n
      When a user asks a question, the following sequence happens in seconds.<\/p>\n\n\n\n
      Step 1: Embed the Query<\/strong><\/p>\n\n\n\n
      The user’s question is converted into a vector embedding using the same embedding model used during indexing.<\/p>\n\n\n\n
      Step 2: Similarity Search<\/strong><\/p>\n\n\n\n
      The query embedding is compared against all the chunk embeddings in the vector database. The chunks with the highest semantic similarity to the query are retrieved \u2014 typically the top 3 to 5 most relevant pieces.<\/p>\n\n\n\n
      This is not a keyword search. If the user asks “What happens if I return a product after 30 days?” and your policy document says “Items returned beyond the 30-day window are not eligible for a full refund,” the semantic similarity between those two phrases will surface that chunk \u2014 even though none of the user’s exact words appear in the chunk.<\/p>\n\n\n\n
      Step 3: Context Injection<\/strong><\/p>\n\n\n\n
      The retrieved chunks are inserted into the prompt alongside the user’s question. The model now receives something like this:<\/p>\n\n\n\n
      You are a helpful customer support assistant. \nAnswer the user's question using ONLY the information provided below.\nIf the answer is not in the provided context, say \"I don't have that information.\"\n\nCONTEXT:\n[Chunk 1: Returns Policy \u2014 Items returned within 30 days...]\n[Chunk 2: Refund Processing \u2014 Refunds are processed within 5-7 business days...]\n[Chunk 3: Exchange Policy \u2014 Customers may exchange items for a different size...]\n\nUSER QUESTION:\nWhat happens if I return a product after 30 days?\n<\/code><\/pre>\n\n\n\n
      Step 4: Generation<\/strong><\/p>\n\n\n\n
      The LLM reads the context and generates a response grounded in the actual retrieved information \u2014 not in its general training knowledge. The answer is accurate, specific to your business, and verifiable against a source document.<\/p>\n\n\n\n
      \n\n\n\n
      The Vector Database: The Heart of RAG<\/h2>\n\n\n\n
      The vector database deserves its own explanation because it is the component that most confuses developers new to RAG.<\/p>\n\n\n\n
      A traditional database stores data in rows and columns and retrieves it by exact match \u2014 “give me the row where customer_id = 1047.” A vector database stores data as high-dimensional numerical vectors and retrieves by similarity \u2014 “give me the chunks that are semantically most similar to this query.”<\/p>\n\n\n\n
      This similarity search is what enables RAG to find the right information even when the user’s exact words do not appear in the document. It is semantic understanding, not keyword matching.<\/p>\n\n\n\n
      Vector Database Options in 2026<\/h3>\n\n\n\n
      Pinecone<\/strong> \u2014 The managed cloud option. No infrastructure to maintain, simple API, strong production performance. Best for teams who want to get RAG working quickly without managing database infrastructure. Has a free tier for development and testing.<\/p>\n\n\n\n
      Weaviate<\/strong> \u2014 Open-source, self-hostable, with hybrid search (vector + keyword combined). Best for teams that need data privacy controls or want to avoid per-query cloud costs at scale.<\/p>\n\n\n\n
      pgvector<\/strong> \u2014 A PostgreSQL extension that adds vector search capability to your existing Postgres database. The pragmatic choice if your application already runs on PostgreSQL. No separate infrastructure, no new technology to learn \u2014 just an extension that adds vector search to a database you already know.<\/p>\n\n\n\n
      MongoDB Atlas Vector Search<\/strong> \u2014 Adds vector search to MongoDB. Best for teams already running MongoDB who want to keep their data layer consolidated.<\/p>\n\n\n\n
      For beginners:<\/strong> Start with Pinecone. Its free tier is generous, the documentation is excellent, and it requires no infrastructure setup. Once you understand how RAG works, you can evaluate whether a different vector database better suits your production requirements.<\/p>\n\n\n\n
      \n\n\n\n
      RAG vs. Fine-Tuning: When to Use Which<\/h2>\n\n\n\n
      This is one of the most common questions developers ask when they first encounter RAG \u2014 and the answer is clearer than most resources make it seem.<\/p>\n\n\n\n
      <\/th>RAG<\/strong><\/th>Fine-Tuning<\/strong><\/th><\/tr><\/thead>
      Best for<\/strong><\/td>Knowledge-intensive tasks (Q&A, document search, support)<\/td>Behaviour and style changes (tone, format, specialised reasoning)<\/td><\/tr>
      Data updates<\/strong><\/td>Easy \u2014 update the vector store, no retraining needed<\/td>Hard \u2014 requires a full retraining run<\/td><\/tr>
      Cost<\/strong><\/td>Low \u2014 embedding + retrieval costs only<\/td>High \u2014 compute-intensive training runs<\/td><\/tr>
      Time to implement<\/strong><\/td>Days to weeks<\/td>Weeks to months<\/td><\/tr>
      Requires ML expertise<\/strong><\/td>No<\/td>Yes<\/td><\/tr>
      Accuracy on your data<\/strong><\/td>High, with good chunking and retrieval<\/td>High, but static at training time<\/td><\/tr>
      When data changes<\/strong><\/td>Handles gracefully<\/td>Requires retraining<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      The practical rule of thumb:<\/strong><\/p>\n\n\n\n
      Use RAG<\/strong> when the problem is “the model doesn’t know about our specific data.” This is the correct solution for 80%+ of real-world AI application requirements.<\/p>\n\n\n\n
      Use fine-tuning<\/strong> when the problem is “the model doesn’t behave the way we need it to” \u2014 when you need to change the model’s style, tone, reasoning patterns, or specialised output format in ways that cannot be achieved through prompting alone.<\/p>\n\n\n\n
      In many production applications, the two are used together: a fine-tuned model for consistent behaviour, with RAG providing the knowledge layer. But for developers starting out, RAG alone solves most practical problems and should be learned first.<\/p>\n\n\n\n
      \n\n\n\n
      Real-World RAG Applications: What Gets Built With This<\/h2>\n\n\n\n
      RAG is not a theoretical concept. It is the architecture behind a significant portion of the AI features being built in production right now. Here are the use cases most relevant to developers in India’s job market.<\/p>\n\n\n\n
      Customer Support Chatbots<\/strong> A chatbot that answers customer queries based on your product documentation, FAQs, and support history. Without RAG, the chatbot gives generic answers. With RAG, it gives answers grounded in your actual policies. This is the most common RAG application in India’s D2C, FinTech, and SaaS sectors.<\/p>\n\n\n\n
      Internal Knowledge Assistants<\/strong> An AI that lets employees query internal documentation \u2014 HR policies, engineering runbooks, project histories, meeting notes \u2014 using natural language. Instead of searching through folders, employees ask a question and get a direct answer with a source reference. Widely adopted in Mumbai’s larger tech companies and professional services firms.<\/p>\n\n\n\n
      Document Q&A Tools<\/strong> Upload a 200-page legal contract, a research report, or a technical manual and ask questions about it in natural language. The AI retrieves the relevant sections and answers based on the actual document content. Used in legal tech, financial research, and engineering documentation workflows.<\/p>\n\n\n\n
      Compliance and Regulatory Assistants<\/strong> In FinTech and banking \u2014 sectors with heavy regulatory documentation \u2014 RAG-based assistants help employees and customers navigate RBI guidelines, SEBI regulations, and internal compliance policies without reading hundreds of pages. A high-growth application area in Mumbai’s financial ecosystem.<\/p>\n\n\n\n
      Personalised Learning Assistants<\/strong> An AI tutor that answers student questions based on a specific course’s curriculum, lecture notes, and reading materials \u2014 not on general internet knowledge. The answers are grounded in what was actually taught, not in what is generally true. An obvious application for EdTech companies, including institutions like TechPaathshala.<\/p>\n\n\n\n
      \n\n\n\n
      How to Start Building: Your First RAG System in Python<\/h2>\n\n\n\n
      Here is a minimal but complete RAG pipeline using LangChain \u2014 the most widely used orchestration framework for RAG in Python. This is the starting point, not a production-grade system \u2014 but it is enough to understand the end-to-end flow and get something running.<\/p>\n\n\n\n
      Prerequisites:<\/strong> Python 3.9+, an OpenAI API key, a Pinecone account (free tier works).<\/p>\n\n\n\n
      # Install dependencies\n# pip install langchain langchain-openai langchain-pinecone pinecone-client\n\nfrom langchain_community.document_loaders import TextLoader\nfrom langchain.text_splitter import RecursiveCharacterTextSplitter\nfrom langchain_openai import OpenAIEmbeddings, ChatOpenAI\nfrom langchain_pinecone import PineconeVectorStore\nfrom langchain.chains import RetrievalQA\nimport os\n\n# --- PHASE 1: BUILD THE KNOWLEDGE BASE ---\n\n# Step 1: Load your document\nloader = TextLoader(\"your_document.txt\")\ndocuments = loader.load()\n\n# Step 2: Chunk the document\nsplitter = RecursiveCharacterTextSplitter(\n    chunk_size=500,\n    chunk_overlap=50\n)\nchunks = splitter.split_documents(documents)\n\n# Step 3: Embed and store in Pinecone\nembeddings = OpenAIEmbeddings(model=\"text-embedding-3-small\")\nvectorstore = PineconeVectorStore.from_documents(\n    documents=chunks,\n    embedding=embeddings,\n    index_name=\"my-first-rag\"   # create this index in Pinecone dashboard first\n)\n\n# --- PHASE 2: ANSWER A QUERY ---\n\n# Set up the retriever (fetches top 3 most relevant chunks)\nretriever = vectorstore.as_retriever(\n    search_kwargs={\"k\": 3}\n)\n\n# Set up the LLM\nllm = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n\n# Build the RAG chain\nrag_chain = RetrievalQA.from_chain_type(\n    llm=llm,\n    retriever=retriever,\n    return_source_documents=True  # shows which chunks were used\n)\n\n# Ask a question\nresult = rag_chain.invoke(\"What is the refund policy for items over 30 days?\")\n\nprint(\"Answer:\", result[\"result\"])\nprint(\"\\nSources used:\")\nfor doc in result[\"source_documents\"]:\n    print(\"-\", doc.page_content[:100], \"...\")\n<\/code><\/pre>\n\n\n\n
      Run this with your own text file and your API keys, and you have a working RAG system. The answer the model gives will be grounded in your document \u2014 and return_source_documents=True<\/code> shows you exactly which chunks were used to generate it, so you can verify and debug the retrieval quality.<\/p>\n\n\n\n
      \n\n\n\n
      Common RAG Mistakes Beginners Make (And How to Avoid Them)<\/h2>\n\n\n\n
      Knowing what can go wrong saves significant debugging time.<\/p>\n\n\n\n
      Mistake 1: Chunks that are too large or too small.<\/strong> Chunks that are too large include irrelevant content that dilutes retrieval precision. Chunks that are too small lose the surrounding context that makes a passage meaningful. Start with 400\u2013600 tokens with 10% overlap, then adjust based on your retrieval quality.<\/p>\n\n\n\n
      Mistake 2: Not testing retrieval separately from generation.<\/strong> The most common RAG failure is poor retrieval \u2014 the wrong chunks are being fetched. Always test your retrieval step in isolation: given a test query, which chunks are retrieved? Are they the right ones? If the retrieval is wrong, fixing the prompt will not help.<\/p>\n\n\n\n
      Mistake 3: Not including source attribution in the response.<\/strong> Users of RAG-based applications need to trust the output. Showing which source document an answer came from \u2014 “According to our Returns Policy (updated March 2026)…” \u2014 builds trust and makes errors catchable. Always design your RAG response to include source references.<\/p>\n\n\n\n
      Mistake 4: Forgetting to update the knowledge base.<\/strong> A RAG system with stale data is worse than no RAG system, because it answers confidently from outdated information. Build a process for updating your vector store when source documents change \u2014 and make it part of your deployment workflow, not an afterthought.<\/p>\n\n\n\n
      Mistake 5: Using RAG for tasks that do not need it.<\/strong> RAG adds latency (the retrieval step takes time) and cost (embedding API calls). For queries that can be answered from the model’s general training knowledge, RAG is unnecessary overhead. Use RAG specifically for knowledge that is proprietary, domain-specific, or time-sensitive.<\/p>\n\n\n\n
      \n\n\n\n
      Why RAG Is a Job-Ready Skill in 2026<\/h2>\n\n\n\n
      Here is the direct career relevance, stated plainly.<\/p>\n\n\n\n
      If you look at AI engineering job descriptions across Mumbai, Bengaluru, Pune, and Hyderabad right now \u2014 at startups, at product companies, at consulting firms with AI practices \u2014 RAG appears constantly. Not as a bonus skill. As a baseline expectation for any role that involves building AI features.<\/p>\n\n\n\n
      Why? Because RAG is the pattern that makes LLMs useful in business applications. Without it, LLMs are impressive but unreliable \u2014 they hallucinate, they have knowledge cutoffs, they cannot access proprietary data. With RAG, they become production-grade tools that businesses can actually rely on. Every company that is building something real with AI is either using RAG or evaluating it.<\/p>\n\n\n\n
      For a beginner developer or final-year student<\/strong>: understanding RAG and being able to build a basic pipeline puts you ahead of most candidates who have only experimented with chatbot interfaces. It signals that you understand how production AI works, not just how to prompt it.<\/p>\n\n\n\n
      For a mid-level developer<\/strong>: adding RAG to your demonstrable skills \u2014 a portfolio project, a GitHub repository with a working implementation, the ability to discuss chunking strategy and retrieval quality in an interview \u2014 is one of the clearest signals of AI engineering readiness in 2026’s job market.<\/p>\n\n\n\n
      The time investment to go from “I have never heard of RAG” to “I can build a working RAG pipeline and explain the key design decisions” is measured in days, not months. The career signal it sends is disproportionate to that investment.<\/p>\n\n\n\n
      \n\n\n\n
      Where to Go from Here<\/h2>\n\n\n\n
      You now understand what RAG is, why it exists, how it works mechanically, and how to start building with it. The next layer \u2014 which you will hit quickly once you start implementing \u2014 involves more advanced topics: hybrid search (combining vector and keyword retrieval), re-ranking retrieved chunks for better precision, multi-document RAG with metadata filtering, evaluating retrieval quality systematically, and building RAG into production applications with streaming and proper error handling.<\/p>\n\n\n\n
      Each of these is learnable. The foundation you now have makes each one significantly easier to pick up.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Imagine you hire a brilliant new employee. They have an MBA from a top institution, can write flawlessly, reason through complex problems, and communicate with confidence. You are impressed. Then, on their first day, you ask them a simple question: “What does our refund policy say?” They pause. Think. Then confidently give you an answer […]<\/p>\n","protected":false},"author":1,"featured_media":826,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"ocean_post_layout":"","ocean_both_sidebars_style":"","ocean_both_sidebars_content_width":0,"ocean_both_sidebars_sidebars_width":0,"ocean_sidebar":"","ocean_second_sidebar":"","ocean_disable_margins":"enable","ocean_add_body_class":"","ocean_shortcode_before_top_bar":"","ocean_shortcode_after_top_bar":"","ocean_shortcode_before_header":"","ocean_shortcode_after_header":"","ocean_has_shortcode":"","ocean_shortcode_after_title":"","ocean_shortcode_before_footer_widgets":"","ocean_shortcode_after_footer_widgets":"","ocean_shortcode_before_footer_bottom":"","ocean_shortcode_after_footer_bottom":"","ocean_display_top_bar":"default","ocean_display_header":"default","ocean_header_style":"","ocean_center_header_left_menu":"","ocean_custom_header_template":"","ocean_custom_logo":0,"ocean_custom_retina_logo":0,"ocean_custom_logo_max_width":0,"ocean_custom_logo_tablet_max_width":0,"ocean_custom_logo_mobile_max_width":0,"ocean_custom_logo_max_height":0,"ocean_custom_logo_tablet_max_height":0,"ocean_custom_logo_mobile_max_height":0,"ocean_header_custom_menu":"","ocean_menu_typo_font_family":"","ocean_menu_typo_font_subset":"","ocean_menu_typo_font_size":0,"ocean_menu_typo_font_size_tablet":0,"ocean_menu_typo_font_size_mobile":0,"ocean_menu_typo_font_size_unit":"px","ocean_menu_typo_font_weight":"","ocean_menu_typo_font_weight_tablet":"","ocean_menu_typo_font_weight_mobile":"","ocean_menu_typo_transform":"","ocean_menu_typo_transform_tablet":"","ocean_menu_typo_transform_mobile":"","ocean_menu_typo_line_height":0,"ocean_menu_typo_line_height_tablet":0,"ocean_menu_typo_line_height_mobile":0,"ocean_menu_typo_line_height_unit":"","ocean_menu_typo_spacing":0,"ocean_menu_typo_spacing_tablet":0,"ocean_menu_typo_spacing_mobile":0,"ocean_menu_typo_spacing_unit":"","ocean_menu_link_color":"","ocean_menu_link_color_hover":"","ocean_menu_link_color_active":"","ocean_menu_link_background":"","ocean_menu_link_hover_background":"","ocean_menu_link_active_background":"","ocean_menu_social_links_bg":"","ocean_menu_social_hover_links_bg":"","ocean_menu_social_links_color":"","ocean_menu_social_hover_links_color":"","ocean_disable_title":"default","ocean_disable_heading":"default","ocean_post_title":"","ocean_post_subheading":"","ocean_post_title_style":"","ocean_post_title_background_color":"","ocean_post_title_background":0,"ocean_post_title_bg_image_position":"","ocean_post_title_bg_image_attachment":"","ocean_post_title_bg_image_repeat":"","ocean_post_title_bg_image_size":"","ocean_post_title_height":0,"ocean_post_title_bg_overlay":0.5,"ocean_post_title_bg_overlay_color":"","ocean_disable_breadcrumbs":"default","ocean_breadcrumbs_color":"","ocean_breadcrumbs_separator_color":"","ocean_breadcrumbs_links_color":"","ocean_breadcrumbs_links_hover_color":"","ocean_display_footer_widgets":"default","ocean_display_footer_bottom":"default","ocean_custom_footer_template":"","ocean_post_oembed":"","ocean_post_self_hosted_media":"","ocean_post_video_embed":"","ocean_link_format":"","ocean_link_format_target":"self","ocean_quote_format":"","ocean_quote_format_link":"post","ocean_gallery_link_images":"on","ocean_gallery_id":[],"footnotes":""},"categories":[3],"tags":[],"class_list":["post-780","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-analytics","entry","has-media"],"acf":[],"_links":{"self":[{"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/posts\/780","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/comments?post=780"}],"version-history":[{"count":2,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/posts\/780\/revisions"}],"predecessor-version":[{"id":906,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/posts\/780\/revisions\/906"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/media\/826"}],"wp:attachment":[{"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/media?parent=780"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/categories?post=780"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techpaathshala.com\/blog\/wp-json\/wp\/v2\/tags?post=780"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}