Agentic AI Projects: FastAPI, MCP, AWS Deploy & Gemini 3

Explore the anatomy of an AI agent with Lanchain and Gemini, detailing the large language model, tools, memory, and thinking that make a React agent outperform a simple chatbot.

Contrast the large language model with the react agent, and learn how tools, memory, sensors, planning and reflection enable agents to act and produce correct results.

Learn how a ReACT agent uses an LLM as the thinker, with an environment, sensor, and tools to act, observe, and loop until answers emerge.

Learn a production-ready model fallback strategy in LangChain, using Gemini 3 flash then Gemini 2.5 flash and optional local models, with error handling, retries, backoff, and safety guardrails.

Explore the four message types in LangChain—human, AI, system, and tool—and learn how to orchestrate tool calls and build a production-grade customer support agent for e-commerce.

Implement a production ready checklist for LangChain AI agents, covering model configuration, tracing, latency, error handling, memory, middleware, guardrails, and prompt engineering.

Set up your Google account, claim $300 in credit, and create Google AI Studio and Langsmith API keys to enable agent tracing, while configuring the dot env file for project.

Create a Google Cloud account, claim 300 USD free credit within 90 days, verify payment info, and activate a project using credit card or UPI to start with GCP.

Learn to create a free Gemini API key in Google AI Studio, attach it to a Google Cloud project, and store it in a .env file for Gemini models.

Explore Google Gemini pricing and Gemini 3 features in Google AI Studio, including context window and grounding options. Learn model selection and use a $300 free credit with LangChain.

Understand rate limits, including rpm and tokens per minute, and choose high‑limit Gemini models for autonomous agents to avoid errors.

Learn how the Gemini rate limit dashboard now displays model-specific quotas, lets you view your active limits, and navigates Gemini 3 flash alongside other models.

Create a Langsmith API key in the Langsmith dashboard settings and copy it to your .env. Enable Langsmith tracing for the multi-agent DBAR-AG project and test loading in your notebook.

Test Google Gemini and Langsmith API keys using the sample code from Google AI Studio, install requirements.txt, and explore LangChain context engineering in this setup lesson.

Explore Gemini 3 bootcamp with Langchain, detailing setup, notebook changes, and essential file creation for building AI agents while outlining model options and core agent fundamentals for beginners.

Explore Google's Gemini 3 model, its advanced reasoning, multi-modal input support, high-resolution image outputs, built-in grounding via google search, and thought signature for robust agent deployments.

Configure a Gemini 3 notebook with built-in Google search and attach external tools like Ullama web search and Wither API. Set up .env with Langsmith and tool API keys.

Load the environment, import ChatGoogleGenerativeAI via LangChain, and use HumanMessage, SystemMessage, and AIMessage to connect a Gemini 3 LLM in notebook workflows.

Explore using Gemini 3 and Gemini 2.5 with LangChain to build real AI agents, compare pricing and token costs, and implement system and user messages.

Analyze how chat models return AI messages with content blocks, explore LangSmith tracing and latency, and compare content versus content blocks across Gemini 3 outputs.

Compare Gemini 3 and Gemini 2 responses, examining the content block format, response metadata, tokens, and cost, while learning how LangChain guides model selection for tasks of varying complexity.

Explore the Gemini 3 model's multi-modal capabilities, focusing on image and PDF processing from URL or local files, and learn to craft multi-model inputs to describe images.

Learn how to analyze a local image with Google Gemini by base64-encoding the file, specifying the MIME type (image/png), and passing the base64 string to the Gemini model.

Attach the Ulama web search tool to the Gemini model, load the Ulama API key, and wrap a Python method as a LangChain tool with a docstring.

Create a free real-time weather search tool with LangChain by turning a Python method into a tool and enabling a Gemini LM to call it.

Organize web search and weather tools into a reusable Python module and bind them to a Gemini model, illustrating tool calling and the distinction between function calls and agent execution.

Learn how to control model thinking in Gemini models by setting thinking budgets and include thoughts, and compare high and low thinking levels across Gemini 2 and Gemini 3.

Explore how to bind Google's in-built tools to a Gemini model, focusing on Google search and code execution to ground responses and enable code-driven queries.

Discover context caching with Google Gemini to cut token usage for PDFs, compare Gemini pricing, and implement caching with Google's generative AI in LangChain.

Upload Apple quarterly PDFs to the Gemini context, build a 30-minute LLM cache for Gemini 2 with a tailored content cache and a system instruction as a financial analyst.

Generate professional infographics using Google's Nano Banana Pro model, combining image and text data with a default 16 by 9 aspect ratio and 1K resolution.

Explore the architecture of AI agents, learn to build your first agent with tracing and tools, and master agentic memory, agentic streaming, and middleware for LangChain projects.

Discover the architecture of an ai agent by mapping the llm, user query, system message, tools, and memory in a simplified flow.

Build and deploy real ai agents by creating an llm-based agent with Google Generative AI, selecting the Gemini 2.5 flash model, and configuring a system prompt.

Execute your LangChain agent by crafting a user query, invoking the agent with the agent state and messages, and inspecting the user and AI messages and final output for tracing.

Learn how LangChain manages agent states as a dictionary of human, AI, tool, and system messages. Explore how these messages shape the agent memory, including short-term and long-term memory.

Configure a structured system prompt and agent guidelines to guide a LangChain AI. Set the model to Gemini 3, adjust thinking level, and enable thought signature for data-driven, concise responses.

Design and compare two system prompts to control agent output quality in LangChain, shaping responses for customer support versus technical expert roles.

Explore the learning path for LangChain ai agents, covering notebook setup, importing Python modules, configuring tools, tracing with Langsmith, sequence and parallel tool calls, and accessing tool context and state.

Set up the notebook for LangChain AI agent projects, enabling RAPTool call handler. Learn to write tool doc strings and parameter hints, and govern sequential and parallel executions.

Explore configuring LangChain tools and tool calling with docstring-driven descriptions to build a real AI agent, using wave search and weather tools in notebook workflows.

Create an autonomous ai agent by wiring LangChain tools, invoking web search with parameter handling, and integrating tools like web search and getweather using a Gemini 2.5 model.

Run your LangChain agent with the first tool call on a weather query. Wrap the user query as a human message and inspect the waterfall trace in langsmith.

Explore how the agent response emerges from a managed agent state, tracing the human, AI, and tool message sequence, tool calls, and live web search for Apple stock.

Master sequencing and parallelism in tool calls for LangChain AI agents by adjusting prompts to run tasks in order or simultaneously, illustrated by stock news and weather queries.

Explore how tool errors affect agent execution and implement graceful handling so a failing tool, such as a 0 division error, doesn't break the pipeline.

Learn to handle tool errors gracefully in LangChain by wrapping tool calls with the wrap tool call hook and middleware, using before agent and before model hooks to intercept failures.

Learn to intercept tool calls with the wrap tool call from LangChain middleware, implement a handle_tool_errors method, and gracefully return tool messages with error details to production-level agents.

Discover how to use the LangChain tool runtime to access agent context and mutable agent state during tool calls, enabling state-aware tools and runtime memory management.

Demonstrate accessing the agent state inside tool calls by typing tool runtime, reading runtime.state.messages, and counting them with the get message count tool. Compare parallel and sequential executions.

Access immutable context data inside tool calls by defining a user context data class, passing it with the agent, and reading it in the tool runtime.

Take a sneak peek at the learning path for LangChain AI agents, covering short term memory, in-memory and escalate saver, Neon Postgres storage, and context offloading with markdown summaries.

Learn short-term memory management for agents, using sqlite, postgresql, or in-memory storage to preserve session histories and agent state across sessions; includes notebook setup and model prompts.

Explore short-term memory in agentic patterns, compare in-memory saver with persistent memory options like SQLite and PostgreSQL, and learn how session or thread IDs influence memory across restarts.

Store chat histories persistently using SQLite by creating a multi thread connection and a checkpoints.db, load messages with SQLiteSaver, and verify data with a SQLite viewer.

Store chat histories remotely on a PostgreSQL server such as neon, using a connection string and .env variables to manage thread history encoded as a string for your AI agent.

explains how context offloading manages llm context windows by summarizing chat histories and storing them locally, then loading summarized messages on demand to reduce context load.

Establish a fresh agent connection with a getAgent method and thread ID config, then summarize conversations and store memories in Postgres SQL as a text file for later access.

Build a tool to load a saved conversation summary from summary.md using user and thread IDs, update the LangChain agent state, and handle missing summaries with informative tool messages.

Load offloaded context in agent state part 2 shows loading a stored conversation summary from a summary path and returning it via a tool call.

Delete previous messages from the agent state after loading the session summary to enable context offloading, leaving only the summary, latest AI message, and subsequent tool interactions.

Explore long term memory in LangChain AI agents, including notebook setup, structured system prompts, and Postgres SQL storage, to save and retrieve user memory across sessions for personalized results.

Distinguish long-term memory from short-term memory in ai agents, storing per-thread state in a vector database and aggregating user preferences across all threads with a user id.

Explore long-term memory setup for LangChain agents, compare short-term and long-term memory, and implement a database-backed store using PostgreSQL for cross-session context.

Set up the Google Generative AI embedding with the JMini embedding 001 model to generate text embeddings and enable semantic memory search via vector space and cosine similarity.

Set up the PostgreSQL connection and 768-vector embedding store for long-term memory, initialize with store.setup, and create a Neon vector database with a user ID.

Implement save user memory as a LangChain tool, storing category-specific information by user id in a Postgres SQL store using runtime, namespace, and a key-value approach.

Build a get user memory tool to read memory from a long-term memory store, using category, runtime, and namespace to retrieve items or report no information.

Attach tools to the agent and configure PostgreSQL-backed short-term and long-term memory, then create an agent using Gemini 2.5 and a web search tool to save user preferences at runtime.

Learn to save user preferences in runtime by storing personal information to a vector database using the system prompt and context. This enables long-term memory for personalization.

Retrieve user preferences across thread IDs by preserving the user ID to maintain long-term memory, and read memory such as location in Mumbai, vegetarian and pasta, and Italian cuisine preferences.

Test personalized results by leveraging long-term memory and user preferences to suggest Mumbai restaurants, using embedding-based semantic search and a store connection to match top results.