How to integrate LangGraph workflow into existing AI chatbot system for recruitment interviews

Other Questions AI Agent
1

I have a Python app that uses AI to interview job candidates and I want to add LangGraph for better conversation flow. Right now my code works but it’s pretty basic. Here’s what I have:

import os
import json
import openai
from datetime import datetime
from personality_traits import BEHAVIORAL_TRAITS

# Store interview data in JSON format
def store_interview_data(interview_log):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"interview_{timestamp}.json"
    with open(filename, 'w') as output_file:
        json.dump(interview_log, output_file, indent=2)
    return filename

# Get candidate information at start
def get_candidate_info():
    ai_model = openai.ChatCompletion()
    greeting_request = "Create a professional greeting to collect the candidate's full name for our interview process. Keep it brief and welcoming."
    ai_response = ai_model.create(messages=[{"role": "user", "content": greeting_request}])
    greeting_text = ai_response.choices[0].message.content
    
    user_name = input(f"\nInterviewer: {greeting_text}\nYou: ").strip()
    print(f"\nInterviewer: Great to meet you, {user_name}. We can start the behavioral questions now.\n")
    return user_name

# Collect candidate responses
def collect_response(question_text):
    while True:
        answer = input(f"\nInterviewer: {question_text}\n\nYour answer: ").strip()
        if answer:
            return answer
        print("Interviewer: Could you please give me an answer?")

# Start interview process
candidate_name = get_candidate_info()
# More interview logic goes here

My current setup does basic question and answer stuff but I need LangGraph to make the conversation smarter and more dynamic. The AI should be able to follow different paths based on what the candidate says.

I tried using some other AI frameworks but I’m new to this and getting stuck on the setup. My main issues are figuring out how to connect LangGraph to what I already built and making the conversation flow better.

What I need help with:

  • Step by step guide to add LangGraph to my existing code
  • Tips for making the AI agent handle different conversation branches
  • Any simpler alternatives if LangGraph is too complex for beginners

I want the system to adapt the questions based on previous answers and maybe ask follow up questions automatically. Has anyone done something similar before?

2

Your code handles the basic interview flow well already. Skip LangGraph for now and try a simpler state machine approach first - especially since you’re new to this. I’ve used LangGraph in recruitment systems before. The main win is handling complex conversation branches without messy conditionals. Your current collect_response and store_interview_data setup can be your foundation. LangGraph shines when you need the AI making decisions about where conversations go. For recruitment, that’s picking follow-up questions based on answer quality, catching when candidates dodge questions, or switching between technical and behavioral topics. Don’t refactor everything yet. Add a simple decision layer to your existing code first. Build a function that analyzes responses and picks the next question type. You’ll understand the conversation patterns before jumping into the full graph structure. Lesson learned the hard way - don’t over-engineer the branching logic upfront. Start basic: incomplete_answer → follow_up_question or good_answer → next_topic. Add complexity once you understand your interview patterns.

3

I added LangGraph to a recruitment system like yours about six months ago. Don’t rewrite everything - just wrap your existing functions in LangGraph nodes. Your get_candidate_info() and collect_response() functions are perfect for this.

Here’s what worked: Create a node that calls your collect_response() function, then pipe the answer to an evaluation node. The evaluator checks response quality and decides whether to ask follow-ups, dig deeper, or move on. Keep your JSON storage - just update the interview log when states change.

The magic happens when LangGraph handles conversation memory and routing while your code does the actual work. Start simple: convert your main interview loop into three nodes - question_asker, response_evaluator, and path_decider. You’ll get the dynamic branching you want without breaking what works.

The learning curve’s pretty manageable if you take it step by step.

4

Honestly, LangGraph’s probably overkill for what you’re doing. Keep your current setup and just add some conditional logic after collect_response(). Something like if len(answer) < 30: ask_clarifying_question() or if 'teamwork' in answer: dive_deeper_on_collaboration(). Way easier than rebuilding everything with graphs, and you’ll figure out which conversation patterns actually work for your interviews before going full LangGraph.

5

I built something similar last year for our hiring pipeline. LangGraph works great for this - it handles conversation state really well.

Here’s how I’d modify your code:

import os
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolExecutor
from typing import TypedDict, List

class InterviewState(TypedDict):
    candidate_name: str
    current_question: str
    answers: List[dict]
    follow_up_needed: bool
    interview_phase: str

def ask_behavioral_question(state: InterviewState):
    # Your existing question logic here
    question = generate_behavioral_question(state["answers"])
    return {"current_question": question}

def evaluate_response(state: InterviewState):
    # Check if follow up is needed
    last_answer = state["answers"][-1]
    needs_followup = len(last_answer["response"]) < 50  # Example logic
    return {"follow_up_needed": needs_followup}

def ask_followup(state: InterviewState):
    followup = f"Can you give me a specific example about {state['current_question']}?"
    return {"current_question": followup, "follow_up_needed": False}

# Build the graph
workflow = StateGraph(InterviewState)
workflow.add_node("ask_question", ask_behavioral_question)
workflow.add_node("evaluate", evaluate_response)
workflow.add_node("followup", ask_followup)

# Add edges for conversation flow
workflow.add_edge("ask_question", "evaluate")
workflow.add_conditional_edges(
    "evaluate",
    lambda x: "followup" if x["follow_up_needed"] else "ask_question"
)

workflow.set_entry_point("ask_question")
app = workflow.compile()

Basically, treat each conversation turn as a state transition. Your existing collect_response function becomes a node in the graph.

LangGraph beats building custom conversation logic. It handles the branching you want without tons of if/else statements.

Pro tip - start with just 2-3 nodes first. I made the mistake of building a huge graph initially and debugging sucked. Add complexity gradually.

For your use case, try these nodes: greeting → ask_question → evaluate_answer → [followup OR next_question OR end_interview].

The docs are actually pretty good once you get the basic concept.