Blog | GeraDeluxer

The Workflow: Using LangGraph for Coordination
The process revolves around LangGraph, a framework that creates workflows capable of branching, looping, and making decisions based on intermediate results. This setup allows agents to handle tasks that go beyond simple commands. Source code in Github.
Here's how the workflow is structured:

typescript
const workflow = new StateGraph(StateAnnotation)
  .addNode("agent", callModel)
  .addNode("retrieve", toolNode)
  .addNode("gradeDocuments", gradeDocuments)
  .addNode("rewrite", rewrite)
  .addNode("generate", generate)
  .addEdge(START, "agent")
  .addConditionalEdges("agent", shouldRetrieve)
  .addEdge("retrieve", "gradeDocuments")
  .addConditionalEdges("gradeDocuments", checkRelevance, { yes: "generate", no: "rewrite" })
  .addEdge("generate", END)
  .addEdge("rewrite", "agent");

StateGraph: Defines the flow using a custom annotation, StateAnnotation.
Nodes: Key tasks in the workflow:
agent: Makes decisions using the language model.
retrieve: Conducts a vector search to find relevant data.
gradeDocuments: Assesses how relevant retrieved documents are.
rewrite: Improves user queries.
generate: Produces the final output using retrieved data.
Edges: Establish connections between nodes and manage the process flow.
Conditional edges guide the workflow based on specific conditions.
Tools: Adding Functionality
LangChain provides tools for specific tasks. Here’s one example:

typescript
const searchDocumentTool = tool(async ({ query }) =&gt; { ... }, {
  name: "search",
  description: "Search and return specific details about Gerardo Del Angel, like work history, certificates, or education",
  schema: z.object({
    query: z.string().describe("The query to use in your search."),
  }),
});

tool(): Creates a tool object.
name and description: Inform the agent about the tool's purpose.
schema: Defines input requirements. Here, the tool processes a query string.
Implementation: Uses a vector store to simulate a search on documents.
Vector Search: Improving Information Retrieval
The system uses vector search to locate relevant documents:

typescript
const vectorStore = await MemoryVectorStore.fromDocuments(
  docSplits,
  new OllamaEmbeddings({ model: 'bge-large' }),
);
const retriever = vectorStore.asRetriever({
searchType: "mmr",
k: 35,
searchKwargs: {
fetchK: 40,
lambda: 0.5,
},
});
const retrievedDocuments = await retriever.invoke(query);

MemoryVectorStore: Stores document embeddings in memory.
OllamaEmbeddings: Generates text embeddings using a specified model.
retriever: Retrieves relevant documents with the mmr algorithm.
LangGraph Node Functions: Steps in the Workflow
Key functions driving the process:
shouldRetrieve Function
Determines whether to retrieve information:

typescript
function shouldRetrieve(state: typeof StateAnnotation.State): string {
const { messages } = state;
const lastMessage = messages[messages.length - 1];

if ("tool_calls" in lastMessage &amp;&amp; Array.isArray(lastMessage.tool_calls) &amp;&amp; lastMessage.tool_calls.length) {
return "retrieve";
}
return END;
}

gradeDocuments Function
Grades the relevance of retrieved documents:

typescript
async function gradeDocuments(state: typeof StateAnnotation.State) {
const { messages } = state;
const question = messages[0].content as string;
const lastMessage = messages[messages.length - 1];

const prompt = ChatPromptTemplate.fromTemplate(`...");

const model = new ChatOllama({
baseUrl: "http://127.0.0.1:11434",
model: "qwen2.5-coder:14b",
}).bindTools([tool]);

const response = await model.invoke({
question,
context: lastMessage.content as string,
});

return { messages: [response] };
}

Other Functions:
callModel: Filters and sends user input to the model.
checkRelevance: Confirms if retrieved documents meet user needs.
rewrite: Refines user questions for better results.
generate: Produces a final answer using relevant documents.
Flexibility with LLMs
Switching models is straightforward. For example:

typescript
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o-mini" }).bindTools(tools);

Install the necessary library to use other providers.
Implementation Overview
The LangGraph workflow is compiled and executed within an API handler:

typescript
if (req.method === 'POST') {
const { prompt } = req.body;

const app = workflow.compile();

const finalState = await app.invoke({
messages: [new HumanMessage(prompt)],
});

res.status(200).json({ message: finalState.messages[finalState.messages.length - 1].content });
}

StateGraph Compilation: Prepares the workflow for execution.
Input and Output: Handles user prompts and sends responses as JSON.
Key Points and Next Steps
Workflow Orchestration: LangGraph handles advanced task coordination.
Information Retrieval: Vector search boosts the system’s ability to find relevant data.
LLM Integration: Supports various models for greater adaptability.
Modularity: Encourages reusable components for specific tasks.
Possible future enhancements include:
Dynamic tool definitions.
Better session management using databases.
Experimenting with diverse LLMs.
Connecting to external data sources.
Refining logic with more conditions and loops.

Building a Versatile AI Agent with LangGraph, Vector Search, and Multiple LLMs

GeraDeluxer