LangGraph state સાથે LLM-સંચાલિત discovery interviews ચલાવો

પરિચય

એન્જિનિયરો ઘણીવાર AI ઉપયોગ-કેસ શોધવા માટે એક-પર-એક ડિસ્કવરી ઇન્ટરવ્યૂ કરવામાં અઠવાડિયાં વિતાવે છે, અને અંતે જુએ છે કે અસંરચિત નોંધો મહત્વપૂર્ણ પેઇન પોઇન્ટ્સને દાટી દે છે અથવા સંપૂર્ણપણે ચૂકી જાય છે. મેન્યુઅલ સંચાલનથી જ્યારે કોઈ સ્ટેકહોલ્ડર ભૂતકાળની નિષ્ફળતા અથવા કોઈ ન ચકાસાયેલી ધારણા તરફ સંકેત કરે ત્યારે વધુ ઊંડાણમાં પૂછપરછ કરવી પણ મુશ્કેલ બને છે. આ પાઠ તમને LangGraph નો ઉપયોગ કરીને DiscoveryInterviewAgent બનાવવાનું શીખવે છે — એક સ્ટેટફુલ, અનુકૂલનશીલ ઇન્ટરવ્યૂ સિસ્ટમ જે સંદર્ભ-આધારિત ફોલો-અપ પ્રશ્નો જનરેટ કરે છે, સંરચિત મેટાડેટા સાથે પ્રતિસાદો કેપ્ચર કરે છે, અને દરેક ક્લાયન્ટ વાતચીતમાંથી AI તકો અને ડેટા તૈયારીની મર્યાદાઓ વિશે સ્કોર કરેલી ઇનસાઇટ્સ કાઢે છે.

મુખ્ય પરિભાષા

• InterviewState — તે TypedDict જે ઇન્ટરવ્યૂના વળાંકો દરમિયાન બદલાતો તમામ ડેટા ધરાવે છે, જેમાં questions_asked, responses, follow_ups_pending, insights, અને turn_count શામેલ છે. LangGraph ગ્રાફનો દરેક નોડ આ એક જ શેર કરેલા ઑબ્જેક્ટમાંથી વાંચે છે અને તેમાં પાછું લખે છે, જેથી દરેક નોડને સંપૂર્ણ સંચિત વાતચીત ઇતિહાસની પહોંચ મળે છે.

• add reducer — InterviewState માં લિસ્ટ ફીલ્ડ્સ પર Annotated[List[T], add] તરીકે લગાવવામાં આવતું એનોટેશન, જે LangGraph ને દરેક નોડના return પર લિસ્ટ બદલવાને બદલે નવી આઇટમો જોડવા (append) માટે સૂચના આપે છે. આ જ કારણે questions_asked અને responses કોઈપણ મેન્યુઅલ લિસ્ટ-મર્જિંગ લોજિક વગર વળાંકો દરમિયાન વધતા રહી શકે છે.

• નોડ ફંક્શન — add_node દ્વારા StateGraph સાથે રજિસ્ટર કરાયેલું એક Python ફંક્શન, જે સંપૂર્ણ વર્તમાન InterviewState મેળવે છે અને ફક્ત તે ફીલ્ડ્સનો આંશિક ડિક્શનરી પરત કરે છે જે તે બદલે છે. LangGraph ગ્રાફના આગલા નોડ પર રૂટ કરતા પહેલાં દરેક નોડના return ને સ્ટેટમાં મર્જ કરે છે.

• DiscoveryInsight — ઇન્ટરવ્યૂમાંથી મળેલું એક સંરચિત તારણ દર્શાવતું Pydantic મૉડલ, જેમાં category (pain_point, opportunity, constraint, અથવા requirement), એક confidence ફ્લોટ, અને supporting_quotes હોય છે જે તારણને સ્ટેકહોલ્ડરનાં ચોક્કસ વિધાનો સાથે જોડે છે, જેથી ડાઉનસ્ટ્રીમ ટ્રેસેબિલિટી જળવાય.

• InterviewSummary — એક Pydantic મૉડલ જે સેશનમાં ઉત્પન્ન થયેલા તમામ DiscoveryInsight ઑબ્જેક્ટ્સને એકત્રિત કરે છે અને સેશન-સ્તરના ફીલ્ડ્સ — key_themes અને recommended_follow_ups — ઉમેરે છે, જે કન્સલ્ટન્ટ્સને કયા AI ઉપયોગ-કેસ સંપૂર્ણ ડેટા તૈયારી મૂલ્યાંકન માટે યોગ્ય છે તે નક્કી કરવા માટે પ્રાથમિકતા-આધારિત દૃશ્ય આપે છે.

• StateGraph — LangGraph નું તે કન્સ્ટ્રક્ટ જે નોડ ફંક્શન્સ અને તેમની વચ્ચેની દિશાયુક્ત એજ રજિસ્ટર કરે છે, જેમાં turn_count જ્યારે max_turns સુધી પહોંચે ત્યારે END તરફનો શરતી રૂટ પણ શામેલ છે, અને આમ છૂટાંછવાયાં જોડાયેલાં ફંક્શન્સને એક સુસંગત, સ્ટેટફુલ ઇન્ટરવ્યૂ લૂપમાં ફેરવે છે.

વિભાવનાઓ

ગ્રાફ તરીકે સ્ટેટફુલ વાતચીત

ડિસ્કવરી ઇન્ટરવ્યૂ બિન-રેખીય હોય છે: ભૂતકાળની નિષ્ફળતા વિશે સ્ટેકહોલ્ડરની સહજ ટિપ્પણી, તેના પછી આવતા સ્ક્રિપ્ટેડ પ્રશ્નના જવાબ કરતાં વધુ મૂલ્યવાન હોઈ શકે છે. ઇન્ટરવ્યૂને LangGraph StateGraph તરીકે દર્શાવવાથી તમે તે બ્રાન્ચિંગ લોજિકને સ્પષ્ટપણે એન્કોડ કરી શકો છો — generate_question analyze_response તરફ રૂટ કરે છે, જે extract_insights તરફ રૂટ કરે છે અથવા બીજા વળાંક માટે પાછું લૂપ કરે છે — કંટ્રોલ ફ્લોને નેસ્ટેડ કન્ડિશનલ્સમાં દાટ્યા વિના. ગ્રાફની એજ વર્ણવે છે કે ક્યારે આગળ વધવું અને ક્યારે વધુ ઊંડાણમાં પૂછપરછ કરવી, જેથી ઇન્ટરવ્યૂનું લોજિક તપાસી શકાય તેવું અને ટેસ્ટ કરી શકાય તેવું બને છે. એજન્ટ કોઈ નિશ્ચિત સ્ક્રિપ્ટને અનુસરતો નથી; તે ગ્રાફ દ્વારા વ્યાખ્યાયિત ટ્રાવર્સલ પોલિસીને અનુસરે છે, અને અત્યાર સુધી સંચિત થયેલી સ્ટેટ નક્કી કરે છે કે દરેક એજ કયો માર્ગ લે છે (જુઓ કોડ વૉકથ્રૂ).

રિડ્યુસર પેટર્ન: બુકકીપિંગ વગર સંચય

LangGraph નું ડિફૉલ્ટ વર્તન એ છે કે નોડ જે કંઈ પરત કરે તેનાથી સ્ટેટ ફીલ્ડને બદલી નાખવું. એક-વળાંકની ક્રિયાપ્રતિક્રિયા માટે તે પૂરતું છે, પરંતુ બહુ-વળાંકના ઇન્ટરવ્યૂમાં questions_asked અને responses દરેક ચક્રમાં વધવા જોઈએ. Annotated[List[T], add] એનોટેશન મર્જ વર્તનને બદલવાથી જોડવા (append) તરફ ફેરવે છે: દરેક નોડ ફક્ત પોતે ઉત્પન્ન કરેલી નવી આઇટમો જ પરત કરે છે, અને LangGraph જોડાણ સંભાળે છે. સેશનના અંતે જ્યારે extract_insights ચાલે છે, ત્યાં સુધીમાં સંપૂર્ણ વાતચીત ઇતિહાસ સ્ટેટમાં પહેલેથી જ એકત્રિત થઈ ગયો હોય છે — કોઈ મેન્યુઅલ લિસ્ટ મેનેજમેન્ટ અથવા ગ્લોબલ એક્યુમ્યુલેટરની જરૂર નથી. આ જ મુખ્ય કારણ છે કે DiscoveryInterviewAgent નોડ્સ વચ્ચે સંચય બગ્સ અથવા સ્ટેટ ડ્રિફ્ટ વગર કોઈપણ સંખ્યાના વળાંકો સુધી ચાલી શકે છે.

સંરચનાનાં બે સ્તર: ઇનસાઇટ વિરુદ્ધ સમરી

આ પાઠ બે Pydantic આઉટપુટ આકારો વચ્ચે તફાવત કરે છે જે અલગ અલગ ઉપભોક્તાઓને સેવા આપે છે. DiscoveryInsight સૂક્ષ્મ છે: દરેક ઑબ્જેક્ટ એક તારણ, તેની શ્રેણી, એક confidence સ્કોર, અને supporting_quotes કેપ્ચર કરે છે જે તેને સ્ટેકહોલ્ડરે વાસ્તવમાં જે કહ્યું તેની સાથે જોડે છે. તારણોને આ સૂક્ષ્મતા પર રાખવાથી તે મશીન-વાંચી શકાય તેવાં બને છે — ડાઉનસ્ટ્રીમ સ્કોરિંગ પગલું ફ્રી ટેક્સ્ટ પાર્સ કર્યા વિના category દ્વારા ફિલ્ટર કરી શકે છે, confidence દ્વારા ક્રમ આપી શકે છે, અથવા related_use_cases દ્વારા ક્લસ્ટર કરી શકે છે.

InterviewSummary સેશન દૃશ્ય છે: તે એક ઇન્ટરવ્યૂની તમામ ઇનસાઇટ્સ એકત્રિત કરે છે અને કન્સલ્ટન્ટ માટે key_themes અને recommended_follow_ups સામે લાવે છે, જેમણે નક્કી કરવું પડે છે કે કયા ઉપયોગ-કેસ સંપૂર્ણ ડેટા તૈયારી મૂલ્યાંકન માટે યોગ્ય છે. બે-સ્તરની ડિઝાઇનનો અર્થ એ છે કે એક જ કાચું ઇન્ટરવ્યૂ આઉટપુટ સ્વયંસંચાલિત સ્કોરિંગ પાઇપલાઇન અને માનવીય નિર્ણય-સ્તર બંનેને પોષે છે — ડેટાની નકલ કર્યા વિના અથવા supporting_quotes જે ટ્રેસેબિલિટી આપે છે તે ગુમાવ્યા વિના (જુઓ કોડ વૉકથ્રૂ).

કોડ વૉકથ્રૂ

હવે જ્યારે તમે DiscoveryInterviewAgent જે ચાર સ્થિતિઓમાંથી પસાર થાય છે તે સમજી ગયા છો — પ્રશ્ન જનરેશન, પ્રતિસાદ કેપ્ચર, ફોલો-અપ વિશ્લેષણ, અને ઇનસાઇટ એક્સટ્રેક્શન — આગલું પગલું એ છે કે તે સ્થિતિઓને LangGraph ગ્રાફમાં જોડવી અને એજન્ટના આઉટપુટને સંરચિત કરતાં Pydantic મૉડલ વ્યાખ્યાયિત કરવાં.

પાયો InterviewState છે, એક TypedDict જેના લિસ્ટ ફીલ્ડ્સ add reducer સાથે Annotated નો ઉપયોગ કરે છે. આ LangGraph ને કહે છે કે દરેક નોડના return પર questions_asked અને responses ને બદલવાને બદલે તેમાં નવી આઇટમો જોડવી, જે એજન્ટને મેન્યુઅલ મર્જિંગ લોજિક વગર વળાંકો દરમિયાન સંપૂર્ણ વાતચીત સંચિત કરવા દે છે.

Code snippetpython
1from langgraph.graph import StateGraph, END
2from typing import TypedDict, List, Annotated
3from operator import add
4
5class InterviewState(TypedDict):
6    """State maintained across interview turns."""
7    topic: str
8    questions_asked: Annotated[List[str], add]
9    responses: Annotated[List[dict], add]
10    follow_ups_pending: List[str]
11    insights: List[dict]
12    turn_count: int
13    max_turns: int
14
15def generate_question(state: InterviewState) -> dict:
16    """Generate the next contextual question."""
17    ...
18
19def analyze_response(state: InterviewState) -> dict:
20    """Analyze response and determine follow-up needs."""
21    ...
22
23def extract_insights(state: InterviewState) -> dict:
24    """Extract structured insights from conversation history."""
25    ...
26
27graph = StateGraph(InterviewState)
28graph.add_node("generate_question", generate_question)
29graph.add_node("analyze_response", analyze_response)
30graph.add_node("extract_insights", extract_insights)

દરેક નોડ ફંક્શન સંપૂર્ણ વર્તમાન સ્ટેટ મેળવે છે અને આંશિક ડિક્શનરી પરત કરે છે; LangGraph આગલો નોડ ચાલે તે પહેલાં return મૂલ્યને સ્ટેટમાં પાછું મર્જ કરે છે. generate_question → analyze_response → extract_insights ચક્ર turn_count max_turns સુધી પહોંચે ત્યાં સુધી ચાલુ રહે છે, જે બિંદુએ ગ્રાફ END તરફ રૂટ કરે છે. add વડે એનોટેટ થયેલાં ફીલ્ડ્સ દરેક ચક્રમાં સંચિત થાય છે, તેથી જ્યારે extract_insights ચાલે છે ત્યાં સુધીમાં સંપૂર્ણ વાતચીત ઇતિહાસ કોઈપણ મેન્યુઅલ બુકકીપિંગ વગર questions_asked અને responses માં ઉપલબ્ધ હોય છે.

ગ્રાફે પૂરતા વળાંકો સંચિત કરી લીધા પછી, extract_insights સંરચિત Pydantic મૉડલ ભરે છે. DiscoveryInsight વ્યક્તિગત તારણો કેપ્ચર કરે છે — પેઇન પોઇન્ટ્સ, તકો, મર્યાદાઓ અને જરૂરિયાતો — સાથે confidence સ્કોર અને સ્ટેકહોલ્ડરે વાસ્તવમાં જે કહ્યું તેની ટ્રેસેબિલિટી માટે supporting_quotes. InterviewSummary સેશનની તમામ ઇનસાઇટ્સ એકત્રિત કરે છે અને recommended_follow_ups અને key_themes સામે લાવે છે જે ડાઉનસ્ટ્રીમ ઉપયોગ-કેસ સ્કોરિંગ પગલાને પોષે છે.

Code snippetpython
1from pydantic import BaseModel
2from typing import List
3
4class DiscoveryInsight(BaseModel):
5    """Structured insight from interview analysis."""
6    category: str  # pain_point, opportunity, constraint, requirement
7    description: str
8    stakeholder: str
9    confidence: float
10    supporting_quotes: List[str]
11    related_use_cases: List[str]
12
13class InterviewSummary(BaseModel):
14    """Complete summary of an interview session."""
15    session_id: str
16    stakeholder_role: str
17    duration_minutes: int
18    insights: List[DiscoveryInsight]
19    recommended_follow_ups: List[str]
20    key_themes: List[str]

DiscoveryInsight અને InterviewSummary વચ્ચેનું વિભાજન હેતુપૂર્વકનું છે: વ્યક્તિગત ઇનસાઇટ્સ સ્વયંસંચાલિત સ્કોરિંગ માટે પૂરતી સૂક્ષ્મ રહે છે જ્યારે સમરી સેશન-સ્તરનું દૃશ્ય આપે છે જે કન્સલ્ટન્ટને કયા AI ઉપયોગ-કેસ સંપૂર્ણ ડેટા તૈયારી મૂલ્યાંકન માટે યોગ્ય છે તેને પ્રાથમિકતા આપવા માટે જરૂરી છે.

તમને ખબર પડશે કે તે કામ કરે છે જ્યારે ગ્રાફ ભૂલ વગર ચાલે અને extract_insights એવું InterviewSummary પરત કરે જેની insights લિસ્ટ ખાલી ન હોય, અને દરેક એન્ટ્રીમાં ભરેલો confidence સ્કોર અને supporting_quotes માં ઓછામાં ઓછી એક એન્ટ્રી હોય.

શિસ્ત-વિશિષ્ટ ઉપયોગ

શું કરવું અને શું ન કરવું

ઉપરની સામગ્રીમાંથી પસાર થયા પછી, નીચેનાં "શું કરવું" અને "શું ન કરવું" તેને વ્યવહારમાં સંક્ષિપ્ત કરે છે.

શું કરવું

1. InterviewState માં questions_asked અને responses ને Annotated[List[...], add] વડે એનોટેટ કરો — add reducer LangGraph ને દરેક નોડના return પર લિસ્ટ બદલવાને બદલે દરેક ચક્રમાં આઇટમો જોડવા કહે છે, જે extract_insights ને કોઈપણ મેન્યુઅલ મર્જિંગ લોજિક વગર સંપૂર્ણ વાતચીત ઇતિહાસની પહોંચ આપે છે.
2. દરેક DiscoveryInsight પર supporting_quotes ભરો — દરેક તારણને સ્ટેકહોલ્ડરની શબ્દશઃ ભાષા સાથે જોડવાથી ઇનસાઇટ્સ વાસ્તવમાં જે કહેવાયું તેની સાથે ટ્રેસ કરી શકાય તેવી રહે છે, જે ડાઉનસ્ટ્રીમ ઉપયોગ-કેસ સ્કોરિંગ પગલાને confidence સ્કોરને બ્લેક-બૉક્સ આઉટપુટ ગણવાને બદલે તેને માન્ય કરવા દે છે.
3. તમારી શરતી એજમાં turn_count ની max_turns સાથે તુલના કરીને END તરફ રૂટ કરો — સ્પષ્ટ સમાપ્તિ નિયંત્રણ એ એકમાત્ર બાબત છે જે generate → analyze → extract ચક્રને અનિશ્ચિત સમય સુધી ચાલતું રોકે છે, અને તે સુનિશ્ચિત કરે છે કે extract_insights ત્યારે જ ચાલે જ્યારે ખાલી ન હોય તેવી insights લિસ્ટ ઉત્પન્ન કરવા માટે પૂરતી વાતચીત સંચિત થઈ ગઈ હોય.

શું ન કરવું

1. questions_asked અથવા responses ને add reducer વગર સાદા List[str] અથવા List[dict] તરીકે જાહેર ન કરો — Annotated[List[...], add] વગર, દરેક નોડનો return ડિક્શનરી ફીલ્ડને સંપૂર્ણપણે ઓવરરાઇટ કરે છે, અગાઉના વળાંકોને મૌનપણે કાઢી નાખે છે, જેથી extract_insights ને સંપૂર્ણ સેશનને બદલે ફક્ત સૌથી તાજેતરની આપ-લે જ દેખાય છે.
2. DiscoveryInsight અને InterviewSummary ને એક જ મૉડલમાં ભેળવી ન દો — તેમને સપાટ કરવાથી પ્રતિ-ઇનસાઇટ confidence સ્કોર અને supporting_quotes ની સૂક્ષ્મતા ગુમાવાય છે જેના પર સ્વયંસંચાલિત સ્કોરિંગ આધાર રાખે છે; InterviewSummary માં સેશન-સ્તરના key_themes અને recommended_follow_ups ને એકત્રિત કરવા માટે વ્યક્તિગત ઇનસાઇટ ઑબ્જેક્ટ્સની જરૂર છે, તેનાથી ઊલટું નહીં.
3. નોડ ફંક્શનમાંથી સંપૂર્ણ સંચિત સ્ટેટ પરત ન કરો — ફક્ત તમે જે ફીલ્ડ્સ બદલી રહ્યા છો તે જ return કરો — દરેક નોડ સંપૂર્ણ InterviewState મેળવે છે પરંતુ તેણે આંશિક ડિક્શનરી જ પરત કરવી જોઈએ; સંપૂર્ણ સ્ટેટ ઑબ્જેક્ટ પરત કરવાથી LangGraph બદલાયા ન હોય તેવાં add-એનોટેટેડ ફીલ્ડ્સને જોડવા માટેની નવી આઇટમો તરીકે અર્થઘટન કરે છે, અને દરેક ચક્રમાં દરેક અગાઉના પ્રશ્ન અને પ્રતિસાદની નકલ થાય છે.