Singapore (SIN) - Bangalore (BLR)
10:30 AM - 1:00 PM
From SGD 489
Agents in developer tools
Many modern IDE assistants already work in “agent mode.” Instead of returning a single static answer, an agent can accept a larger task and perform a sequence of operations:
* Search the codebase,
* Inspect Git history,
* Run commands in a terminal,
* Iterate until the task is resolved.
This multi-step execution can include several LLM calls and multiple tool invocations.
Build agents or use pre-built agents
You can choose different approaches to adopt agents:
* Use hosted, pre-built agents (platform examples: agent.ai).
* Use no-code automation platforms such as n8n to compose workflows.
* Build custom agents programmatically with frameworks like LangChain or LangGraph.
Tools: the agent’s action primitives
A tool is the code that enables an agent to interact with a third-party API or system. For the flight example, each airline would have a tool that searches or books flights. The agent uses the tool to retrieve structured data and consults the LLM to determine the next action.
How applications interact — a short API refresher
Humans use websites and mobile apps (UI). Applications talking to other applications use APIs that return structured data (JSON) rather than scraping HTML.
Example: a scraped HTML search result (simplified)
```html theme={null}
Real-world use cases
* Troubleshooting: An agent inspects Git history and code and identifies the commit that removed a UI element; it can propose a fix or revert plan.
* Backend development: An agent runs queries against test databases (via MCP server) to validate API behavior while you build.
* Data engineering: Give an agent access to Stripe, BigQuery, and Metabase via MCPs. The agent can correlate data across systems to find missing invoice details.
Illustrative agent tool output (sample)
```text theme={null}
Called MCP tool execute-query ✓
Mumshad 🚀, after updating the query to join invoices using both charges.invoice_id = invoices.id OR invoices.charge_id = charges.id, here's what we get for your charge:
Transaction ID | Date | Amount | Currency | Status | Product Name | Product Type | Interval
ch_3RPNosLnvBo4cHTg1V2oPR4x | 2025-05-16 12:57:06 | 22140 | USD | succeeded | KodeKloud STANDARD | standard | year
Conclusion:
• The product details are now correctly retrieved! 🎉
• The charge is for KodeKloud STANDARD (type: standard), with a yearly interval.
Key Fix:
• Always join invoices using both charges.invoice_id = invoices.id and invoices.charge_id = charges.id to catch all cases.
```
Part 2 — How (preview of the hands-on lab)
This lesson includes an interactive FlightSim MCP lab that demonstrates an MCP server and a client integrated into an in-browser VS Code environment. The lab guides you through configuring the client, setting environment variables (API keys provided in the lab), enabling the FlightSim MCP server, and performing searches and bookings through an agent.
Important environment variables used in the lab (stored in `~/.bash_profile`)
```bash theme={null}
export CLAUDE_API_KEY="Sk-kkAI-EXAMPLE-CLAUDE-KEY"
export GROQ_API_KEY="Sk-kkAI-EXAMPLE-GROQ-KEY"
export OPENAI_API_BASE="https://dev.kk-ai-keys.kodekloud.com/v1"
export AZURE_OPENAI_ENDPOINT="https://dev.kk-ai-keys.kodekloud.com/openai"
export OPENAI_API_KEY="Sk-kkAI-EXAMPLE-OPENAI-KEY"
export GROQ_API_BASE="https://dev.kk-ai-keys.kodekloud.com"
export AZURE_OPENAI_API_KEY="Sk-kkAI-EXAMPLE-AZURE-KEY"
export CLAUDE_API_BASE="https://dev.kk-ai-keys.kodekloud.com"
```
Client configuration (VS Code / Cline extension)
1. Open the client UI (robot icon in the left panel).
2. Select “Use your own API key” and choose the OpenAI-compatible provider.
3. Paste `OPENAI_API_BASE` and `OPENAI_API_KEY` from `~/.bash_profile`.
4. Choose a model ID (for example `openai/gpt-4.1`) and click “Let’s Go”.
5. Test by sending a short message — the model should respond.
Adding an MCP server for FlightSim
In the client settings (Manage MCP Servers → Configure MCP Servers), provide a JSON config (for example `cline_mcp_settings.json`) that declares MCP servers. Example FlightSim entry:
```json theme={null}
{
"mcpServers": {
"flight-sim": {
"command": "/bin/bash",
"args": ["/root/flight-sim-mcp/flight-sim-mcp.sh"]
}
}
}
```
After saving this configuration, the client will show FlightSim MCP as available. The agent can query the server for capabilities (e.g., `search_flights`, `book_flight`) and will request your approval before any external call is made.
Example booking payload (what the MCP server expects when booking a flight)
```json theme={null}
{
"flight_id": "AAAA878-2025",
"passengers": [
{
"first_name": "Mumshad",
"last_name": "Mannambe",
"email": "mumshad@example.com",
"phone": "+1 234 345 3456"
}
],
"seat_class": "economy"
}
```
Preview: small Python agent-client flow (illustrative)
This example shows two user clients and demonstrates private thread isolation using `langgraph_sdk` (async). It is illustrative and intended to show high level semantics:
```python theme={null}
# example_langgraph_demo.py
import asyncio
from langgraph_sdk import get_client
async def main():
# Create clients for both users
alice = get_client(
url="http://localhost:2024",
headers={"Authorization": "Bearer user1-token"}
)
bob = get_client(
url="http://localhost:2024",
headers={"Authorization": "Bearer user2-token"}
)
# Alice creates an assistant
alice_assistant = await alice.assistants.create()
print(f"✅ Alice created assistant: {alice_assistant['assistant_id']}")
# Alice creates a thread and chats
alice_thread = await alice.threads.create()
print(f"✅ Alice created thread: {alice_thread['thread_id']}")
await alice.runs.create(
thread_id=alice_thread["thread_id"],
assistant_id="agent",
input={"messages": [{"role": "user", "content": "Hi, this is Alice's private chat"}]}
)
# Bob tries to access Alice's thread
try:
await bob.threads.get(alice_thread["thread_id"])
print("❌ Bob shouldn't see Alice's thread!")
except Exception as e:
print("✅ Bob correctly denied access:", e)
# Bob creates his own thread
bob_thread = await bob.threads.create()
await bob.runs.create(
thread_id=bob_thread["thread_id"],
assistant_id="agent",
input={"messages": [{"role": "user", "content": "Hi, this is Bob's private chat"}]}
)
print(f"✅ Bob created his own thread: {bob_thread['thread_id']}")
# List threads - each user only sees their own
alice_threads = await alice.threads.search()
bob_threads = await bob.threads.search()
print(f"✅ Alice sees {len(alice_threads)} thread(s)")
print(f"✅ Bob sees {len(bob_threads)} thread(s)")
if __name__ == "__main__":
asyncio.run(main())
```
Hands-on lab summary
* The FlightSim MCP lab runs in an in-browser VS Code environment.
* The lab provides example API keys and a FlightSim MCP server script.
* You will configure the client, enable the MCP server, ask the agent to search flights, approve agent tool calls, and try a booking via the FlightSim MCP.
* The agent demonstrates the full observe → think → act loop: discover capability → call tool → ask for approval → act → return results.