Build Salesforce AI Agent with LangChain, Groq

Building a Salesforce AI Agent with LangChain and Groq in Google Colab

Imagine interacting with your Salesforce instance using natural language queries instead of writing SOQL, navigating setup menus, or building reports. This article demonstrates how to construct a conversational AI agent that bridges this gap, enabling direct data access through plain English.

By combining LangChain's agent framework, Groq's low-latency LLM inference, and the langchain-salesforce integration, you can build an agent that interprets natural language, generates valid SOQL, executes it against your Salesforce org, validates results through iterative reasoning, and presents human-readable answers with structured data visualizations.

The Challenge with Traditional Programmatic Salesforce Access

Traditional Salesforce integrations require developers to manually write SOQL, understand the object model and namespace prefixes, and manage aspects like pagination, governor limits, and error recovery. This complexity creates a barrier for business analysts, sales operations teams, and executives seeking direct data access.

A LangChain agent fundamentally alters this dynamic. By providing the agent with a set of Salesforce tools, it can:

• Accept questions in plain English.
• Reason about relevant objects and fields.
• Determine correct API names, including namespace resolution.
• Estimate query code before execution.
• Return answers in a formatted table, abstracting away complexity.

This article aims to:

• Demonstrate the construction of a production-ready Salesforce AI agent using the langchain-salesforce package.
• Explain the architecture and design patterns for handling Salesforce-specific challenges such as namespace prefixes, governor limits, and SOQL syntax validation.
• Provide a complete, ready-to-use Google Colab notebook deployable within minutes.
• Illustrate best practices for error handling, rate limit management, and conversational memory.
• Showcase Groq's LPU-powered inference for sub-second latency in interactive agent loops.
• Empower both technical developers and business users to query Salesforce data without writing SOQL.

Upon completion, you will have a functional Salesforce AI agent capable of answering complex questions like:

• "Show me the top five accounts by created date."
• "How many open opportunities were created this month?"

Scope

This solution focuses exclusively on standard SOQL data queries against the Salesforce REST API. It does not cover:

• DML operations (INSERT/UPDATE/DELETE).
• Bulk API, Streaming API, Tooling API, GraphQL API, Apex execution, or Salesforce Flow automation.

Architecture Overview: ReAct Pattern

The agent operates on a ReAct (Reasoning + Acting) pattern. It iteratively reasons about the user's question, selects the appropriate tool, and executes it until a final answer is formulated.

• Interface: Users interact via a Colab cell's ask() function or an optional Gradio web UI.
• Agent and Memory: The LangGraph agent receives questions and utilizes MemorySaver to maintain conversation history, enabling follow-up questions.
• Reasoning (LLM): The agent prompts the Groq LLM with the question, history, and available tools. The LLM decides the next action.
• Tool Execution: The agent invokes selected tools (e.g., find_object_api_name, execute_soql) that interface with the Salesforce API.
• Result Processing: Tool results are returned to the LLM for assessment. If the question isn't answered, another tool may be called; otherwise, a final answer is formulated.
• Output: The final answer is displayed, and Salesforce data is stored in a global pandas DataFrame named last_df for further analysis.

Implementation Procedure

Prerequisites

• Google Account for Colab access.
• Salesforce Credentials:
  • Username
  • Password
  • Security token (obtain from Setup → My Personal Information → Reset Security Token).
• Groq API Key (free tier available at https://console.groq.com/keys).
• Salesforce Permissions:
  • "API Enabled"
  • Read access to queried objects.
  • Access to the Tooling API (for metadata queries).

Step-by-Step Implementation

Step 1 – Environment Setup (Cell 1)

Install necessary packages and verify imports:

!pip install -q langchain langchain_groq langgraph langchain-core langchain-salesforce pandas gradio

import sys
print(f"Python {sys.version.split()[0]}")

try:
	from langchain_salesforce import SalesforceTool
	print("langchain-salesforce imported successfully")
except ImportError as e:
	print(f"langchain-salesforce import failed: {e}")

Key Libraries:

• Langchain: Core agent orchestration framework.
• langchain_groq: LangChain adapter for Groq's fast inference API.
• Langgraph: Graph-based agent executor for the ReAct loop and state management.
• langchain-salesforce: Official Salesforce integration wrapping the REST API and handling authentication.
• Pandas: Converts Salesforce records into DataFrames for structured display and analysis.
• Gradio: Optional web UI for sharing the agent with non-technical users.

Step 2 – Establishing a Salesforce Connection (Cell 2)

This block initializes a single SalesforceTool connection used by all agent tools. It connects to your Salesforce org and validates with a minimal query. The SalesforceTool from langchain-salesforce internally wraps the simple-salesforce library, using username, password, and security token against Salesforce’s OAuth endpoint for authentication.

Critical Security Warning: This notebook utilizes Google Colab’s Secrets feature. Access the Secrets panel (key icon in the left sidebar) and define the following credentials:

Name	Description	Notebook Access
src_username	Your Salesforce username.	True
src_password	Your Salesforce password.	True
src_token	Your Salesforce security token.	True
COLAB_GROK_API_KEY	Your API key from Groq.	True

This ensures secure credential fetching, preventing accidental exposure.

from langchain_salesforce import SalesforceTool
from google.colab import userdata
import json, pandas as pd

def init_salesforce() -> SalesforceTool:
	"""Initialise SalesforceTool and verify connectivity with a test query."""
	print("Connecting to Salesforce...")
	try:
		sf_tool = SalesforceTool(
			username=userdata.get('src_username'),
			password=userdata.get('src_password'),
			security_token=userdata.get('src_token'),
			domain="test" # Change to "" for production
		)

		# Minimal connectivity check
	test = sf_tool.invoke({"operation": "query", "query": "SELECT Id, Name FROM Account LIMIT 1"})
	records = test.get("records", [])
		print(f"Connected → {len(records)} test record(s) fetched")
		return sf_tool

	except Exception as e:
		msg = str(e)
		print(f"\n Connection failed: {type(e).__name__}")
		if "INVALID_LOGIN" in msg:
			print("  Fix: wrong username/password/token combination")
		elif "INVALID_SESSION_ID" in msg:
			print("  Fix: regenerate security token in Salesforce Setup")
		elif "INSUFFICIENT_ACCESS" in msg:
			print("  Fix: grant 'API Enabled' permission to your user")
		else:
			print(f" Debug: {msg}")
		raise


sf = init_salesforce()

Step 3 – LLM Initialization (Cell 3)

Instantiate the language model that drives the agent's reasoning. For service continuity, two models are configured: a primary and a fallback. The agent automatically switches to the fallback if the primary hits its daily rate limit.

• Primary Model: llama-3.3-70b-versatile (100k tokens/day free tier)
• Fallback Model: meta-llama/llama-4-scout-17b-16e-instruct (1M tokens/day free tier)

The LLM is configured with three critical parameters for reliable behavior:

• temperature=0: Ensures deterministic output. The same question consistently generates the same SOQL and query.
• max_tokens=2048: Prevents truncation of tool-call JSON during generation.
• max_retries=2: Gracefully handles transient network errors.

from langchain_core.tools import tool
from langchain_groq import ChatGroq
import os, re, json

os.environ["GROQ_API_KEY"] = userdata.get('COLAB_GROK_API_KEY')

GROQ_MODEL_PRIMARY = "llama-3.3-70b-versatile"
GROQ_MODEL_FALLBACK = "meta-llama/llama-4-scout-17b-16e-instruct"
GROQ_MODEL_ACTIVE = GROQ_MODEL_PRIMARY
# updated by ask() on rate-limit switch

def make_llm(model: str) -> ChatGroq:
	"""Create a ChatGroq instance. Called at init and when switching fallback model."""
	return ChatGroq(
		model=model,
		temperature=0, # deterministic — same question always generates same SOQL
		max_tokens=2048, # cap output to prevent mid-JSON truncation → tool_use_failed
		max_retries=2, # retry transient HTTP errors (rate limits handled separately)
	)

llm = make_llm(GROQ_MODEL_PRIMARY)
print(f"  LLM initialised: {llm.model_name}")
print(f"  temperature=0 | max_tokens=2048")
print(f"  Fallback model: {GROQ_MODEL_FALLBACK}")

Step 4 – Agent Tools Definition (Cell 4)

The agent's capabilities are defined as Python functions decorated with @tool. This example showcases the get_object_fields tool, which retrieves all fields of a Salesforce object via the standard describe endpoint.

# ══════════════════════════════════════════════════════════════════════════════
# TOOL 2 — get_object_fields
# ══════════════════════════════════════════════════════════════════════════════
# Returns ALL fields for a given sObject via the standard describe endpoint.
# For each field it returns:
# name, label, type, nillable, calculated (formula), length, updateable

@tool
def get_object_fields(object_name: str) -> str:
	"""Get ALL fields for a Salesforce object using the standard describe endpoint.
	Use when the user asks 'what fields does X have' or 'show me the columns of X'.
	Returns a DataFrame displayed inline and stored in last_df."""
	global last_df
	try:
		# Regex guard: Salesforce API names are alphanumeric
		if not re.match(r'^[a-zA-Z0-9_]+$', object_name):
			raise ValueError("Invalid object name format.")

		response = sf.describe(object_name)
		fields_data = []
		for field in response.get('fields', []):
			fields_data.append({
				'Name': field.get('name'),
				'Label': field.get('label'),
				'Type': field.get('type'),
				'Nillable': field.get('nillable'),
				'Calculated': field.get('calculated'),
				'Length': field.get('length'),
				'Updateable': field.get('updateable')
			})

		last_df = pd.DataFrame(fields_data)
		return last_df.to_markdown(index=False)

	except Exception as e:
		print(f"Error describing object '{object_name}': {e}")
		return f"Could not retrieve fields for {object_name}. Check API name and permissions."

Key Takeaways

• A LangChain agent can abstract complex SOQL queries, making Salesforce data accessible via natural language.
• The langchain-salesforce integration simplifies API interactions and authentication.
• Groq's LLMs provide low-latency inference for a responsive agent experience.
• Implementing a ReAct pattern is crucial for iterative reasoning and tool execution.
• Securely managing credentials using Colab Secrets is essential for production-aware deployments.