Building AI Agents with LangGraph

# Write your Python code here
import time
import random
import sys
from typing import TypedDict
from langgraph.graph import StateGraph, END
# ---------------------- STATE ----------------------
class CollegeState(TypedDict):
 user_query: str
  detected_intent: str
   response_text: str
    final_reply: str
    # ---------------------- AGENTS ----------------------
    class AdmissionDesk:
     def reply(self):
      return (
       "\n===== ADMISSION DESK =====\n"
        "Admission Process:\n"
         "1. Register on the admission portal.\n"
          "2. Submit JEE/CUET score.\n"
           "3. Upload 10th & 12th documents.\n"
            "4. Pay counselling fee.\n"
             "5. Participate in counselling rounds.\n"
              )
              class ExamDesk:
               def reply(self):
                return (
                 "\n===== EXAMINATION CELL =====\n"
                 "• Semester Exams start from 10 December.\n"
                  "• Admit card available before 5 days.\n"
                   "• Minimum 75% attendance required.\n"
                    )
                    class FeeDesk:
                     def reply(self):
                      return (
                       "\n===== FEES SECTION =====\n"
                        "Tuition Fee : ₹65,000\n"
                         "Development Fee : ₹12,000\n"
                          "Hostel Fee : ₹35,000\n"
                           "Security Deposit : ₹5,000 (Refundable)\n"
                            "Total : ₹1,17,000\n"
                             )
                             class ScholarshipDesk:
                              def reply(self):
                               return (
                                "\n===== SCHOLARSHIP CELL =====\n"
                                 "• Merit Scholarship\n"
                                  "• NSP Scholarship\n"
                                   "• e-Kalyan Scholarship\n"
                                    "• PMSSS Scheme\n"
                                     "• Government Category Benefits\n"
                                      )
                                      # ---------------------- ROUTER ----------------------
                                      class IntentRouter:
                                        def __init__(self):
                                           self.keywords = {
                                            "admission": [
                                             "admission", "apply", "join", "enroll",
                                              "jee", "cuet", "cutoff", "process"
                                               ],
                                                "exam": [
                                                 "exam", "semester", "result",
                                                  "hall ticket", "admit card", "marks"
                                                   ],
                                                    "fees": [
                                                     "fee", "fees", "money",
                                                      "tuition", "hostel", "payment"
                                                       ],
                                                        "scholarship": [
                                                         "scholarship", "financial aid",
                                                          "waiver", "mcm", "nsp"
                                                           ],
                                                            "help": [
                                                             "help", "menu", "options"
                                                              ],
                                                               "exit": [
                                                                "exit", "quit", "bye", "close"
                                                                 ]
                                                                  }
                                                                  def classify(self, query):
                                                                     query = query.lower()
                                                                      for intent, words in self.keywords.items():
                                                                       for word in words:
                                                                        if word in query:
                                                                         return intent
                                                                          return "unknown"
                                                                          # ---------------------- GRAPH NODES ----------------------
                                                                          def detect_intent_node(state: CollegeState):
                                                                           router = IntentRouter()
                                                                            return {
                                                                             "detected_intent": router.classify(state["user_query"])
                                                                              }
                                                                              def admission_node(state: CollegeState):
                                                                               return {
                                                                                "response_text": AdmissionDesk().reply()
                                                                                 }
                                                                                 def exam_node(state: CollegeState):
                                                                                  return {
                                                                                     "response_text": ExamDesk().reply()
                                                                                      }
                                                                                      def fees_node(state: CollegeState):
                                                                                       return {
                                                                                        "response_text": FeeDesk().reply()
                                                                                         }
                                                                                         def scholarship_node(state: CollegeState):
                                                                                          return {
                                                                                           "response_text": ScholarshipDesk().reply()
                                                                                            }
                                                                                            def final_response_node(state: CollegeState):
                                                                                             intent = state["detected_intent"]
                                                                                              if intent == "help":
                                                                                               message = (
                                                                                                "\n===== HELP MENU =====\n"
                                                                                                 "You can ask questions like:\n"
                                                                                                  "• Admission process\n"
                                                                                                   "• Exam schedule\n"
                                                                                                    "• Fee structure\n"
                                                                                                     "• Scholarship details\n\n"
                                                                                                      "Type 'exit' to close the assistant.
                                                                                               )
                                                                                                elif intent == "exit":
                                                                                                 goodbye = [
                                                                                                  "Thank you for visiting. Goodbye!",
                                                                                                   "Session ended successfully.",
                                                                                                    "Have a great day. See you again!"
                                                                                                     ]
                                                                                                      message = random.choice(goodbye)
                                                                                                       elif intent == "unknown":
                                                                                                        message = (
                                                                                                         "\nSorry! I can only answer questions related to:\n"
                                                                                                          "• Admission\n"
                                                                                                           "• Exams\n"
                                                                                                            "• Fees\n"
                                                                                                             "• Scholarships\n\n"
                                                                                                              "Type 'help' to see available options."
                                                                                                               )
                                                                                                                else:
                                                                                                                 message = state["response_text"]
                                                                                                                  return {
                                                                                                                   "final_reply": message
                                                                                                                    }
                                                                                                                    # ---------------------- ROUTING-------------
                                                                                                                    def next_node(state: CollegeState):
                                                                                                                       routes = {
                                                                                                                        "admission": "admission_node",
                                                                                                                         "exam": "exam_node",
                                                                                                                          "fees": "fees_node",
                                                                                                                           "scholarship": "scholarship_node"
                                                                                                                            }
                                                                                                                             return routes.get(
                                                                                                                              state["detected_intent"],
                                                                                                                               "final_response_node"
                                                                                                                                )
                                                                                                                                # ---------------------- BUILD GRAPH ----------------------
                                                                                                                                graph = StateGraph(CollegeState)
                                                                                                                                # Add Nodes
                                                                                                                                graph.add_node("intent_node", detect_intent_node)
                                                                                                                                graph.add_node("admission_node", admission_node)
                                                                                                                                graph.add_node("exam_node", exam_node)
                                                                                                                                graph.add_node("fees_node", fees_node)
                                                                                                                                graph.add_node("scholarship_node", scholarship_node)
                                                                                                                                graph.add_node("final_response_node", final_response_node)
                                               # Entry Point
                                               graph.set_entry_point("intent_node")
                                               # Conditional Routing
                                               graph.add_conditional_edges(
                                                "intent_node",
                                                 next_node,
                                                  {
                                                   "admission_node": "admission_node",
                                                    "exam_node": "exam_node",
                                                     "fees_node": "fees_node",
                                                      "scholarship_node": "scholarship_node",
                                                       "final_response_node": "final_response_node",
                                                        }
                                                        )
                                                        # Return to Final Response
                                                        graph.add_edge("admission_node", "final_response_node")
                                                        graph.add_edge("exam_node", "final_response_node")
                                                        graph.add_edge("fees_node", "final_response_node")
                                                        graph.add_edge("scholarship_node", "final_response_node")
                                                        # End Workflow
                                                        graph.add_edge("final_response_node", END)
                                                        # Compile Graph
                                                        college_bot = graph.compile()
                                                        # ---------------------- DISPLAY FUNCTION--------
                    def type_writer(message, speed=0.015):
                       for ch in message:
                        sys.stdout.write(ch)
                         sys.stdout.flush()
                          time.sleep(speed)
                           print()
                           # ---------------------- MAIN PROGRAM ----------------------
                           def main():
                            print("=" * 65)
                             print(" UNIVERSITY AI ASSISTANT USING LANGGRAPH")
                              print("=" * 65)
                               student = input("\nEnter Your Name : ").strip().title()
                                if student == "":
                                 student = "Student"
                                  greeting = (
                                   f"\nHello {student}!\n"
                                    "Welcome to the University AI Assistant.\n"
                                     "Type 'help' to see available services."
                                      )
                                       type_writer(greeting)
                                        while True:
                                                 query = input(f"\n{student} >> ").strip()
                                                  if query == "":
                                                   continue
                                                    state = {
                                                     "user_query": query,
                                                      "detected_intent": "",
                                                       "response_text": "",
                                                        "final_reply": ""
                                                         }
                                                          result = college_bot.invoke(state)
                                                           print("\n" + "-" * 65)
                                                            type_writer(result["final_reply"])
                                                             print("-" * 65)
                                                              if result["detected_intent"] == "exit":
                                                               break
                                                               # ---------------------- PROGRAM START ----------------------
                                                               if __name__ == "__main__":
                                                                try:
                                                                 main()
                                                                  except KeyboardInterrupt:
                                                                   print("\n\nProgram Closed Successfully.")
                                                                    sys.exit(0)                                                                

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

import re
from typing import Annotated, List, TypedDict
from langgraph.graph import END, START, StateGraph

# Reducer function jo history ko sahi se manage aur append karega
def append_history(old_list: List[str], new_list: List[str]) -> List[str]:
    return old_list + new_list

# 1. State definition fixed using LangGraph updates pattern
class UniversityState(TypedDict):
    query: str
    intent: str
    department: str
    response: str
    history: Annotated[List[str], append_history]

# Better keyword patterns matching (taaki false positives na ho)
DEPARTMENTS = {
    r"\b(cse|computer|cs)\b": "Computer Science Engineering",
    r"\b(ece|electronics)\b": "Electronics and Communication Engineering",
    r"\b(eee|electrical)\b": "Electrical Engineering",
    r"\b(me|mech|mechanical)\b": "Mechanical Engineering",
    r"\b(civil)\b": "Civil Engineering",
}

def classifier(state: UniversityState):
    text = state["query"].lower()
    
    if any(word in text for word in ["admission", "admit", "apply", "eligibility", "cutoff"]):
        intent = "admission"
    elif any(word in text for word in ["fee", "fees", "payment", "tuition"]):
        intent = "fees"
    elif any(word in text for word in ["exam", "semester", "result", "admit card", "routine"]):
        intent = "exam"
    elif any(word in text for word in ["scholarship", "e-kalyan", "financial"]):
        intent = "scholarship"
    else:
        intent = "unknown"
        
    return {"intent": intent}

def department_detector(state: UniversityState):
    text = state["query"].lower()
    department = "General"
    
    for pattern, value in DEPARTMENTS.items():
        if re.search(pattern, text):
            department = value
            break
            
    return {"department": department}

def admission_agent(state: UniversityState):
    dept = state["department"]
    response = f"""
Admission Agent
Department : {dept}

Admission Process
1. Fill Online Application Form
2. Upload Documents
   • 10th & 12th Marksheet
   • Identity Proof / ID Documents
   • Passport Size Photo
3. Pay Registration Fee
4. Submit Application
5. Download Acknowledgement
6. Wait for Merit List
7. Document Verification
8. Final Admission Confirmation
"""
    return {"response": response}

def fees_agent(state: UniversityState):
    dept = state["department"]
    response = f"""
Fees Agent
Department : {dept}

Approx Fees
Tuition Fee      : ₹73,000
Hostel Fee       : ₹20,000
Registration Fee : ₹5,000
Library Fee      : ₹2,000
Exam Fee         : ₹2,500
"""
    return {"response": response}

def exam_agent(state: UniversityState):
    response = """
Exam Agent
Semester Exam
Mid Semester : September
End Semester : December
Admit Card   : Available before exam
Result       : Usually published within 30 days.
"""
    return {"response": response}

def scholarship_agent(state: UniversityState):
    response = """
Scholarship Agent
Available Scholarships
• Merit Scholarship
• SC / ST / OBC Scholarship
• E-Kalyan Scholarship
• NSP Scholarship
"""
    return {"response": response}

def unknown_agent(state: UniversityState):
    return {
        "response": """
❌ Sorry I can't understand what you are trying to say.
I can answer only about:
• Admission
• Fees
• Exam
• Scholarship
So please ask me any of these.
"""
    }

def formatter(state: UniversityState):
    # History generator jo direct new entries update karega
    return {
        "history": [f"User : {state['query']}", f"Bot  : {state['response']}"],
        "response": state["response"]
    }

def router(state: UniversityState):
    return state["intent"]

# --- Workflow Setup ---
workflow = StateGraph(UniversityState)

workflow.add_node("Classifier", classifier)
workflow.add_node("Department", department_detector)
workflow.add_node("Admission", admission_agent)
workflow.add_node("Fees", fees_agent)
workflow.add_node("Exam", exam_agent)
workflow.add_node("Scholarship", scholarship_agent)
workflow.add_node("Unknown", unknown_agent)
workflow.add_node("Formatter", formatter)

workflow.add_edge(START, "Classifier")
workflow.add_edge("Classifier", "Department")

workflow.add_conditional_edges(
    "Department",
    router,
    {
        "admission": "Admission",
        "fees": "Fees",
        "exam": "Exam",
        "scholarship": "Scholarship",
        "unknown": "Unknown"
    }
)

workflow.add_edge("Admission", "Formatter")
workflow.add_edge("Fees", "Formatter")
workflow.add_edge("Exam", "Formatter")
workflow.add_edge("Scholarship", "Formatter")
workflow.add_edge("Unknown", "Formatter")
workflow.add_edge("Formatter", END)

app = workflow.compile()

def chat():
    print("=" * 60)
    print(" UNIVERSITY AI MULTI-AGENT SYSTEM")
    print("=" * 60)
    print("\nAvailable Topics: Admission, Fees, Exam, Scholarship")
    print("Departments: CSE, ECE, EEE, Mechanical, Civil")
    print("------------------------------------------------------------")
    print("Type 'bye' to exit.\n")

    # Local runtime configuration state manage karne ke liye
    chat_history = []

    while True:
        query = input("You : ").strip()
        if query.lower() in ["bye", "exit", "quit"]:
            print("\nBot : Thank you. Have a nice day!")
            break

        if not query:
            continue

        state = {
            "query": query,
            "intent": "",
            "department": "",
            "response": "",
            "history": chat_history
        }

        result = app.invoke(state)
        chat_history = result["history"]

        print("\nBot :")
        print(result["response"])
        print("-" * 40)

if __name__ == "__main__":
    chat()

Open full submission →

from typing import TypedDict, List
from langgraph.graph import StateGraph, START, END
class UniversityState(TypedDict):
    query: str
    intent: str
    department: str
    response: str
    history: List[str]
DEPARTMENTS = {
    "cse": "Computer Science Engineering",
    "computer": "Computer Science Engineering",
    "cs": "Computer Science Engineering",

    "ece": "Electronics and Communication Engineering",
    "electronics": "Electronics and Communication Engineering",

    "eee": "Electrical Engineering",
    "electrical": "Electrical Engineering",

    "me": "Mechanical Engineering",
    "mech": "Mechanical Engineering",
    "mechanical": "Mechanical Engineering",

    "civil": "Civil Engineering",
}
def classifier(state: UniversityState):

    text = state["query"].lower()

    if any(word in text for word in [
        "admission",
        "admit",
        "apply",
        "eligibility",
        "cutoff"
    ]):
        intent = "admission"

    elif any(word in text for word in [
        "fee",
        "fees",
        "payment",
        "tuition"
    ]):
        intent = "fees"

    elif any(word in text for word in [
        "exam",
        "semester",
        "result",
        "admit card",
        "routine"
    ]):
        intent = "exam"

    elif any(word in text for word in [
        "scholarship",
        "e-kalyan",
        "financial"
    ]):
        intent = "scholarship"
   
    else:
        intent = "unknown"

    return {"intent": intent}
def department_detector(state: UniversityState):

    text = state["query"].lower()

    department = "General"

    for key, value in DEPARTMENTS.items():

        if key in text:
            department = value
            break

    return {"department": department}
def admission_agent(state: UniversityState):

    dept = state["department"]

    response = f"""
 Admission Agent

Department : {dept}

Admission Process

1. Fill Online Application Form

2. Upload Documents
   • 10th Marksheet
   • 12th Marksheet
   • Aadhaar Card
   • Passport Size Photo

3. Pay Registration Fee

4. Submit Application

5. Download Acknowledgement

6. Wait for Merit List

7. Document Verification

8. Final Admission Confirmation
"""

    return {"response": response}
def fees_agent(state: UniversityState):

    dept = state["department"]

    response = f"""
 Fees Agent

Department : {dept}

Approx Fees

Tuition Fee      : ₹73,000

Hostel Fee       : ₹20,000

Registration Fee : ₹5,000

Library Fee      : ₹2,000

Exam Fee         : ₹2,500
"""

    return {"response": response}
def exam_agent(state: UniversityState):

    response = """
 Exam Agent

Semester Exam

Mid Semester :
September

End Semester :
December

Admit Card :
Available before exam

Result :
Usually published within 30 days.
"""

    return {"response": response}
def scholarship_agent(state: UniversityState):

    response = """
 Scholarship Agent

Available Scholarships

• Merit Scholarship

• SC Scholarship

• ST Scholarship

• OBC Scholarship

• E-Kalyan Scholarship

• NSP Scholarship
"""

    return {"response": response}
def unknown_agent(state: UniversityState):

    return {
        "response":
"""
❌ Sorry I can't understand what are you trying to say

I can answer only about

• Admission

• Fees

• Exam

• Scholarship
So please ask me any of these 
"""
    }
def formatter(state: UniversityState):

    history = state.get("history", [])

    history.append(f"User : {state['query']}")
    history.append(f"Bot  : {state['response']}")

    return {
        "response": state["response"],
        "history": history
    }
def router(state: UniversityState):

    return state["intent"]
workflow = StateGraph(UniversityState)

workflow.add_node("Classifier", classifier)
workflow.add_node("Department", department_detector)

workflow.add_node("Admission", admission_agent)
workflow.add_node("Fees", fees_agent)
workflow.add_node("Exam", exam_agent)
workflow.add_node("Scholarship", scholarship_agent)
workflow.add_node("Unknown", unknown_agent)

workflow.add_node("Formatter", formatter)

workflow.add_edge(START, "Classifier")

workflow.add_edge("Classifier", "Department")


workflow.add_conditional_edges(

    "Department",

    router,

    {

        "admission": "Admission",

        "fees": "Fees",

        "exam": "Exam",

        "scholarship": "Scholarship",

        "unknown": "Unknown"

    }

)


workflow.add_edge("Admission", "Formatter")
workflow.add_edge("Fees", "Formatter")
workflow.add_edge("Exam", "Formatter")
workflow.add_edge("Scholarship", "Formatter")
workflow.add_edge("Unknown", "Formatter")

workflow.add_edge("Formatter", END)

app = workflow.compile()
def chat():

    print("=" * 60)
    print(" UNIVERSITY AI MULTI-AGENT SYSTEM")
    print("=" * 60)

    print("\nAvailable Topics")
    print("------------------------------")
    print("Admission")
    print("Fees")
    print("Exam")
    print("Scholarship")
    print("------------------------------")

    print("\nDepartments")
    print("------------------------------")
    print("CSE")
    print("ECE")
    print("EEE")
    print("Mechanical")
    print("Civil")
    print("------------------------------")

    print("\nType 'bye' to exit.\n")

    history = []

    while True:

        query = input("You : ").strip()

        if query.lower() in ["bye", "exit", "quit"]:

            print("\nBot :  Thank you. Have a nice day!")
            break

        state = {

            "query": query,

            "intent": "",

            "department": "",

            "response": "",

            "history": history

        }

        result = app.invoke(state)

        history = result["history"]

        print("\nBot :")
        print(result["response"])
        print()
if __name__ == "__main__":
    chat()

Open full submission →

# Write your Python code here
https://github.com/Gautam-54432465/AI-Multiagent.git

Open full submission →

import os
from dotenv import load_dotenv

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END

from langchain_google_genai import ChatGoogleGenerativeAI


load_dotenv()

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")

if not GOOGLE_API_KEY:
    raise ValueError(
        "GOOGLE_API_KEY not found.\n"
        "Create a .env file and add:\n"
        "GOOGLE_API_KEY=YOUR_API_KEY"
    )



class GeminiLLM:
    """
    Wrapper class for Google Gemini.
    """

    def __init__(self):

        self.model = ChatGoogleGenerativeAI(
            model="gemini-3.5-flash",
            google_api_key=GOOGLE_API_KEY,
            temperature=0.3,
        )

    def generate(self, prompt: str) -> str:

        try:

            response = self.model.invoke(prompt)

            if isinstance(response.content, str):
                return response.content

            if isinstance(response.content, list):

                text = ""

                for block in response.content:

                    if (
                        isinstance(block, dict)
                        and block.get("type") == "text"
                    ):
                        text += block.get("text", "")

                return text.strip()

            return str(response.content)

        except Exception as e:

            return f"Error: {e}"


gemini = GeminiLLM()



# STATE


class CollegeState(TypedDict):

    query: str

    intent: str

    response: str



# PYTHON INTENT CLASSIFIER
# (NO GEMINI API CALL)


def classify_intent(query: str) -> str:

    q = query.lower()

    admission_keywords = [
        "admission",
        "apply",
        "application",
        "eligibility",
        "document",
        "admit",
        "counselling",
        "cutoff",
    ]

    exam_keywords = [
        "exam",
        "result",
        "attendance",
        "semester",
        "internal",
        "backlog",
        "syllabus",
        "schedule",
    ]

    fees_keywords = [
        "fee",
        "fees",
        "hostel fee",
        "payment",
        "refund",
        "tuition",
        "bus fee",
    ]

    scholarship_keywords = [
        "scholarship",
        "nsp",
        "merit",
        "government scholarship",
        "state scholarship",
    ]

    for word in admission_keywords:

        if word in q:
            return "admission"

    for word in exam_keywords:

        if word in q:
            return "exam"

    for word in fees_keywords:

        if word in q:
            return "fees"

    for word in scholarship_keywords:

        if word in q:
            return "scholarship"

    return "unknown"



# INTENT NODE


def intent_classifier(state: CollegeState):

    state["intent"] = classify_intent(state["query"])

    return state



# ROUTER


def router(state: CollegeState):

    return state["intent"]



# UNKNOWN AGENT


def unknown_agent(state: CollegeState):

    state["response"] = (
        "Sorry, I can only answer questions related to:\n\n"
        "• Admission\n"
        "• Examination\n"
        "• Fees\n"
        "• Scholarship"
    )

    return state

# ADMISSION AGENT


def admission_agent(state: CollegeState):
    prompt = f"""
You are a college admission assistant.

Answer only admission-related questions in simple language.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state



# EXAM AGENT


def exam_agent(state: CollegeState):

    prompt = f"""
You are the Examination Department Assistant.

Answer ONLY examination-related questions.

Topics:

- Semester Exam
- Internal Exam
- Exam Schedule
- Result
- Attendance
- Syllabus
- Backlog Exam

If the question is outside examination,
politely refuse.

Student Question:

{state["query"]}

Provide a short and professional answer.
"""

    state["response"] = gemini.generate(prompt)

    return state



# FEES AGENT


def fees_agent(state: CollegeState):

    prompt = f"""
You are the College Accounts Department.

Answer ONLY fee-related questions.

Topics:

- Tuition Fee
- Hostel Fee
- Bus Fee
- Payment Method
- Refund Policy
- Fee Receipt

If the question is unrelated,
politely refuse.

Student Question:

{state["query"]}

Give a concise answer using bullet points whenever possible.
"""

    state["response"] = gemini.generate(prompt)

    return state



# SCHOLARSHIP AGENT


def scholarship_agent(state: CollegeState):

    prompt = f"""
You are the Scholarship Help Desk.

Answer ONLY scholarship-related questions.

Topics:

- NSP
- Government Scholarship
- Merit Scholarship
- State Scholarship
- Eligibility
- Required Documents
- Scholarship Application

If the question is unrelated,
politely refuse.

Student Question:

{state["query"]}

Respond in simple language.
"""

    state["response"] = gemini.generate(prompt)

    return state




def response_agent(state: CollegeState):
    """
    Optional response formatter.

    No additional Gemini API call.
    This keeps the project faster and avoids
    consuming extra API quota.
    """

    response = state["response"].strip()

    if not response:
        response = "No response generated."

    state["response"] = response

    return state

# BUILD LANGGRAPH


builder = StateGraph(CollegeState)


# Register Nodes


builder.add_node("intent_classifier", intent_classifier)
builder.add_node("admission", admission_agent)
builder.add_node("exam", exam_agent)
builder.add_node("fees", fees_agent)
builder.add_node("scholarship", scholarship_agent)
builder.add_node("unknown", unknown_agent)
builder.add_node("response", response_agent)


# START


builder.add_edge(START, "intent_classifier")


# Conditional Routing

builder.add_conditional_edges(
    "intent_classifier",
    router,
    {
        "admission": "admission",
        "exam": "exam",
        "fees": "fees",
        "scholarship": "scholarship",
        "unknown": "unknown",
    },
)


builder.add_edge("admission", "response")
builder.add_edge("exam", "response")
builder.add_edge("fees", "response")
builder.add_edge("scholarship", "response")
builder.add_edge("unknown", "response")

# -----------------------------
# Response -> END
# -----------------------------

builder.add_edge("response", END)

# Compile Graph
graph = builder.compile()



def main():

    print("=" * 60)
    print(" College Information Multi-Agent AI agent ")
    print("=" * 60)
    print("Type 'exit' to quit.\n")

    while True:

        query = input(" Student: ").strip()

        if query.lower() in ["exit", "quit"]:

            print("\n👋 Thank you for using the  my agent !")
            break

        state = {
            "query": query,
            "intent": "",
            "response": "",
        }

        try:

            result = graph.invoke(state)

            print("\n----------------------------------------")
            print(f"Detected Intent : {result['intent']}")
            print("----------------------------------------")

            print("\n Agent:\n")
            print(result["response"])
            print()

        except Exception as e:

            print("\n❌ Error")
            print(e)
            print()


if __name__ == "__main__":
    main()

Open full submission →

from typing import TypedDict, List
from langgraph.graph import StateGraph, END
import re


class StudentState(TypedDict):
    query: str
        cleaned_query: str
            intent: str
                confidence: float
                    response: str
                        history: List[str]


                        ADMISSION_KEYWORDS = [
                            "admission","apply","application","join","enroll",
                                "enrollment","eligibility","document","documents","registration"
                                ]

                                EXAM_KEYWORDS = [
                                    "exam","examination","test","result",
                                        "schedule","routine","timetable","marks"
                                        ]

                                        FEE_KEYWORDS = [
                                            "fee","fees","payment","tuition",
                                                "installment","amount","online payment"
                                                ]

                                                SCHOLARSHIP_KEYWORDS = [
                                                    "scholarship","financial aid","grant",
                                                        "stipend","funding"
                                                        ]


                                                        def preprocess_query(query: str) -> str:
                                                            query = query.lower()
                                                                query = re.sub(r"[^a-zA-Z0-9 ]", "", query)
                                                                    query = re.sub(r"\s+", " ", query)
                                                                        return query.strip()


                                                                        def calculate_confidence(keyword_count: int) -> float:
                                                                            if keyword_count >= 3:
                                                                                    return 0.98
                                                                                        elif keyword_count == 2:
                                                                                                return 0.90
                                                                                                    elif keyword_count == 1:
                                                                                                            return 0.80
                                                                                                                return 0.30


                                                                                                                def preprocessing_agent(state: StudentState):
                                                                                                                    state["cleaned_query"] = preprocess_query(state["query"])
                                                                                                                        return state


                                                                                                                        def intent_classifier(state: StudentState):
                                                                                                                            query = state["cleaned_query"]

                                                                                                                                scores = {
                                                                                                                                        "admission": sum(k in query for k in ADMISSION_KEYWORDS),
                                                                                                                                                "exam": sum(k in query for k in EXAM_KEYWORDS),
                                                                                                                                                        "fees": sum(k in query for k in FEE_KEYWORDS),
                                                                                                                                                                "scholarship": sum(k in query for k in SCHOLARSHIP_KEYWORDS),
                                                                                                                                                                    }

                                                                                                                                                                        intent = max(scores, key=scores.get)
                                                                                                                                                                            highest = scores[intent]

                                                                                                                                                                                if highest == 0:
                                                                                                                                                                                        state["intent"] = "unknown"
                                                                                                                                                                                                state["confidence"] = 0.30
                                                                                                                                                                                                    else:
                                                                                                                                                                                                            state["intent"] = intent
                                                                                                                                                                                                                    state["confidence"] = calculate_confidence(highest)

                                                                                                                                                                                                                        return state


                                                                                                                                                                                                                        def admission_agent(state):
                                                                                                                                                                                                                            state["response"] = """Admission Information

                                                                                                                                                                                                                            • Admission starts in June every year.
                                                                                                                                                                                                                            • Fill out the application form.
                                                                                                                                                                                                                            • Upload required documents.
                                                                                                                                                                                                                            • Pay the application fee.
                                                                                                                                                                                                                            • Wait for the merit list.
                                                                                                                                                                                                                            • Complete document verification."""
                                                                                                                                                                                                                                return state


                                                                                                                                                                                                                                def exam_agent(state):
                                                                                                                                                                                                                                    state["response"] = """Examination Information

                                                                                                                                                                                                                                    • Check the timetable on the student portal.
                                                                                                                                                                                                                                    • Download your admit card.
                                                                                                                                                                                                                                    • Carry your ID card.
                                                                                                                                                                                                                                    • Results are published after evaluation."""
                                                                                                                                                                                                                                        return state


                                                                                                                                                                                                                                        def fees_agent(state):
                                                                                                                                                                                                                                            state["response"] = """Fees Information

                                                                                                                                                                                                                                            • Pay fees online or at the Accounts Office.
                                                                                                                                                                                                                                            • UPI, Net Banking and Cards are supported.
                                                                                                                                                                                                                                            • Download the payment receipt.
                                                                                                                                                                                                                                            • And fees depend on the mode of admission. (paid or free shet)"""
                                                                                                                                                                                                                                                return state


                                                                                                                                                                                                                                                def scholarship_agent(state):
                                                                                                                                                                                                                                                    state["response"] = """Scholarship Information

                                                                                                                                                                                                                                                    • Eligible students can apply online.
                                                                                                                                                                                                                                                    • Submit all required documents.
                                                                                                                                                                                                                                                    • Apply before the deadline."""
                                                                                                                                                                                                                                                        return state


                                                                                                                                                                                                                                                        def unknown_agent(state):
                                                                                                                                                                                                                                                            state["response"] = """Sorry, I couldn't understand your question.

                                                                                                                                                                                                                                                            Please ask about:
                                                                                                                                                                                                                                                            • Admission
                                                                                                                                                                                                                                                            • Examination
                                                                                                                                                                                                                                                            • Fees
                                                                                                                                                                                                                                                            • Scholarship"""
                                                                                                                                                                                                                                                                return state


                                                                                                                                                                                                                                                                def router(state):
                                                                                                                                                                                                                                                                    return state["intent"]


                                                                                                                                                                                                                                                                    def save_history(state):
                                                                                                                                                                                                                                                                        state["history"].append(state["query"])
                                                                                                                                                                                                                                                                            return state


                                                                                                                                                                                                                                                                            def response_formatter(state):
                                                                                                                                                                                                                                                                                state["response"] = f"""
                                                                                                                                                                                                                                                                                ========================================
                                                                                                                                                                                                                                                                                College Student Assistant
                                                                                                                                                                                                                                                                                ========================================

                                                                                                                                                                                                                                                                                {state["response"]}

                                                                                                                                                                                                                                                                                ========================================
                                                                                                                                                                                                                                                                                """
                                                                                                                                                                                                                                                                                    return state


                                                                                                                                                                                                                                                                                    def response_agent(state):
                                                                                                                                                                                                                                                                                        print(state["response"])
                                                                                                                                                                                                                                                                                            return state


                                                                                                                                                                                                                                                                                            workflow = StateGraph(StudentState)

                                                                                                                                                                                                                                                                                            workflow.add_node("Preprocessing", preprocessing_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("Intent", intent_classifier)
                                                                                                                                                                                                                                                                                            workflow.add_node("Admission", admission_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("Exam", exam_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("Fees", fees_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("Scholarship", scholarship_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("Unknown", unknown_agent)
                                                                                                                                                                                                                                                                                            workflow.add_node("History", save_history)
                                                                                                                                                                                                                                                                                            workflow.add_node("Formatter", response_formatter)
                                                                                                                                                                                                                                                                                            workflow.add_node("Response", response_agent)

                                                                                                                                                                                                                                                                                            workflow.set_entry_point("Preprocessing")
                                                                                                                                                                                                                                                                                            workflow.add_edge("Preprocessing", "Intent")

                                                                                                                                                                                                                                                                                            workflow.add_conditional_edges(
                                                                                                                                                                                                                                                                                                "Intent",
                                                                                                                                                                                                                                                                                                    router,
                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                "admission": "Admission",
                                                                                                                                                                                                                                                                                                                        "exam": "Exam",
                                                                                                                                                                                                                                                                                                                                "fees": "Fees",
                                                                                                                                                                                                                                                                                                                                        "scholarship": "Scholarship",
                                                                                                                                                                                                                                                                                                                                                "unknown": "Unknown",
                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                    for node in ["Admission", "Exam", "Fees", "Scholarship", "Unknown"]:
                                                                                                                                                                                                                                                                                                                                                        workflow.add_edge(node, "History")

                                                                                                                                                                                                                                                                                                                                                        workflow.add_edge("History", "Formatter")
                                                                                                                                                                                                                                                                                                                                                        workflow.add_edge("Formatter", "Response")
                                                                                                                                                                                                                                                                                                                                                        workflow.add_edge("Response", END)

                                                                                                                                                                                                                                                                                                                                                        app = workflow.compile()


                                                                                                                                                                                                                                                                                                                                                        def main():
                                                                                                                                                                                                                                                                                                                                                            print("=" * 50)
                                                                                                                                                                                                                                                                                                                                                                print("COLLEGE STUDENT ASSISTANT USING LANGGRAPH")
                                                                                                                                                                                                                                                                                                                                                                    print("=" * 50)
                                                                                                                                                                                                                                                                                                                                                                        print("Type 'exit' to quit.\n")

                                                                                                                                                                                                                                                                                                                                                                            history = []

                                                                                                                                                                                                                                                                                                                                                                                while True:
                                                                                                                                                                                                                                                                                                                                                                                        query = input("Ask your question: ").strip()

                                                                                                                                                                                                                                                                                                                                                                                                if query.lower() in ("exit", "quit"):
                                                                                                                                                                                                                                                                                                                                                                                                            print("Goodbye!")
                                                                                                                                                                                                                                                                                                                                                                                                                        break

                                                                                                                                                                                                                                                                                                                                                                                                                                if not query:
                                                                                                                                                                                                                                                                                                                                                                                                                                            print("Please enter a question.\n")
                                                                                                                                                                                                                                                                                                                                                                                                                                                        continue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                state = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "query": query,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "cleaned_query": "",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "intent": "",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "confidence": 0.0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "response": "",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "history": history,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        app.invoke(state)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if __name__ == "__main__":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            main()

Open full submission →

https://github.com/Deepak-kumar-om/Multi-Agent-project.git

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END

# --------------------------
# State Definition
# --------------------------
class StudentState(TypedDict):
    query: str
    intent: str
    response: str

# --------------------------
# Intent Classifier
# --------------------------
def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state

# --------------------------
# Admission Agent
# --------------------------
def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. "
        "Students should submit the application form with all required documents."
    )
    return state

# --------------------------
# Exam Agent
# --------------------------
def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state

# --------------------------
# Fees Agent
# --------------------------
def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state

# --------------------------
# Scholarship Agent
# --------------------------
def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state

# --------------------------
# Response Agent
# --------------------------
def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state

# --------------------------
# Routing Function
# --------------------------
def route(state: StudentState):
    return state["intent"]

# --------------------------
# Create Graph
# --------------------------
workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")

workflow.add_edge("Response Agent", END)

app = workflow.compile()

# --------------------------
# Run Program
# --------------------------
print("===== College Student Assistant =====")
query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

import os
from dotenv import load_dotenv

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END

from langchain_google_genai import ChatGoogleGenerativeAI


load_dotenv()

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")

if not GOOGLE_API_KEY:
    raise ValueError(
        "GOOGLE_API_KEY not found.\n"
        "Create a .env file and add:\n"
        "GOOGLE_API_KEY=YOUR_API_KEY"
    )



class GeminiLLM:
    """
    Wrapper class for Google Gemini.
    """

    def __init__(self):

        self.model = ChatGoogleGenerativeAI(
            model="gemini-3.5-flash",
            google_api_key=GOOGLE_API_KEY,
            temperature=0.3,
        )

    def generate(self, prompt: str) -> str:

        try:

            response = self.model.invoke(prompt)

            if isinstance(response.content, str):
                return response.content

            if isinstance(response.content, list):

                text = ""

                for block in response.content:

                    if (
                        isinstance(block, dict)
                        and block.get("type") == "text"
                    ):
                        text += block.get("text", "")

                return text.strip()

            return str(response.content)

        except Exception as e:

            return f"Error: {e}"


gemini = GeminiLLM()



# STATE


class CollegeState(TypedDict):

    query: str

    intent: str

    response: str



# PYTHON INTENT CLASSIFIER
# (NO GEMINI API CALL)


def classify_intent(query: str) -> str:

    q = query.lower()

    admission_keywords = [
        "admission",
        "apply",
        "application",
        "eligibility",
        "document",
        "admit",
        "counselling",
        "cutoff",
    ]

    exam_keywords = [
        "exam",
        "result",
        "attendance",
        "semester",
        "internal",
        "backlog",
        "syllabus",
        "schedule",
    ]

    fees_keywords = [
        "fee",
        "fees",
        "hostel fee",
        "payment",
        "refund",
        "tuition",
        "bus fee",
    ]

    scholarship_keywords = [
        "scholarship",
        "nsp",
        "merit",
        "government scholarship",
        "state scholarship",
    ]

    for word in admission_keywords:

        if word in q:
            return "admission"

    for word in exam_keywords:

        if word in q:
            return "exam"

    for word in fees_keywords:

        if word in q:
            return "fees"

    for word in scholarship_keywords:

        if word in q:
            return "scholarship"

    return "unknown"



# INTENT NODE


def intent_classifier(state: CollegeState):

    state["intent"] = classify_intent(state["query"])

    return state



# ROUTER


def router(state: CollegeState):

    return state["intent"]



# UNKNOWN AGENT


def unknown_agent(state: CollegeState):

    state["response"] = (
        "Sorry, I can only answer questions related to:\n\n"
        "• Admission\n"
        "• Examination\n"
        "• Fees\n"
        "• Scholarship"
    )

    return state

def exam_agent(state: CollegeState):

    prompt = f"""
You are a college exam assistant.

Answer only examination-related questions.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state


# ADMISSION AGENT

def admission_agent(state: CollegeState):

    prompt = f"""
You are a college admission assistant.

Answer only admission-related questions in simple language.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state



# FEES AGENT


def fees_agent(state: CollegeState):
    prompt = f"""
You are a college fees assistant.

Answer only fee-related questions.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state



# SCHOLARSHIP AGENT


def scholarship_agent(state: CollegeState):

    prompt = f"""
You are a scholarship assistant.

Answer only scholarship-related questions.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state




def response_agent(state: CollegeState):
    """
    Optional response formatter.

    No additional Gemini API call.
    This keeps the project faster and avoids
    consuming extra API quota.
    """

    response = state["response"].strip()

    if not response:
        response = "No response generated."

    state["response"] = response

    return state

# BUILD LANGGRAPH


builder = StateGraph(CollegeState)


# Register Nodes


builder.add_node("intent_classifier", intent_classifier)
builder.add_node("admission", admission_agent)
builder.add_node("exam", exam_agent)
builder.add_node("fees", fees_agent)
builder.add_node("scholarship", scholarship_agent)
builder.add_node("unknown", unknown_agent)
builder.add_node("response", response_agent)


# START


builder.add_edge(START, "intent_classifier")


# Conditional Routing

builder.add_conditional_edges(
    "intent_classifier",
    router,
    {
        "admission": "admission",
        "exam": "exam",
        "fees": "fees",
        "scholarship": "scholarship",
        "unknown": "unknown",
    },
)


builder.add_edge("admission", "response")
builder.add_edge("exam", "response")
builder.add_edge("fees", "response")
builder.add_edge("scholarship", "response")
builder.add_edge("unknown", "response")

# -----------------------------
# Response -> END
# -----------------------------

builder.add_edge("response", END)

# Compile Graph
graph = builder.compile()



def main():

    print("=" * 60)
    print(" College Information Multi-Agent AI agent ")
    print("=" * 60)
    print("Type 'exit' to quit.\n")

    while True:

        query = input(" Student: ").strip()

        if query.lower() in ["exit", "quit"]:

            print("\n Thank you budy")
            break

        state = {
            "query": query,
            "intent": "",
            "response": "",
        }

        try:

            result = graph.invoke(state)

            print("\n----------------------------------------")
            print(f"Detected Intent : {result['intent']}")
            print("----------------------------------------")

            print("\n Agent:\n")
            print(result["response"])
            print()

        except Exception as e:

            print("\n❌ Error")
            print(e)
            print()


if __name__ == "__main__":
    main()

Open full submission →

https://github.com/Shivam870988/AI-Career-Assistant-LangGraph

Open full submission →

%PDF-1.4
%����
1 0 obj
<<
/Type /Pages
/Count 10
/Kids [ 4 0 R 12 0 R 19 0 R 21 0 R 23 0 R 25 0 R 27 0 R 29 0 R 31 0 R 33 0 R ]
>>
endobj
2 0 obj
<<
/Producer (PyPDF2)
>>
endobj
3 0 obj
<<
/Type /Catalog
/Pages 1 0 R
>>
endobj
4 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 11 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
5 0 obj
<<
/ca 1
/BM /Normal
>>
endobj
6 0 obj
<<
/Type /Font
/Subtype /Type0
/BaseFont /AAAAAA+ArialMT
/Encoding /Identity-H
/DescendantFonts [ 7 0 R ]
/ToUnicode 10 0 R
>>
endobj
7 0 obj
<<
/Type /Font
/FontDescriptor 8 0 R
/BaseFont /AAAAAA+ArialMT
/Subtype /CIDFontType2
/CIDToGIDMap /Identity
/CIDSystemInfo <<
/Registry (Adobe)
/Ordering (Identity)
/Supplement 0
>>
/W [ 0 [ 750 0 0 277.83203 277.83203 354.98047 556.15234 0 889.16016 666.99219 190.91797 333.00781 333.00781 389.16016 583.98438 277.83203 333.00781 277.83203 277.83203 ] 19 26 556.15234 29 [ 277.83203 0 0 583.98438 583.98438 0 0 666.99219 666.99219 722.16797 722.16797 666.99219 610.83984 777.83203 722.16797 277.83203 ] 46 [ 666.99219 556.15234 833.00781 722.16797 777.83203 666.99219 0 722.16797 666.99219 610.83984 722.16797 666.99219 943.84766 666.99219 666.99219 ] 62 64 277.83203 66 69 556.15234 71 72 556.15234 73 [ 277.83203 556.15234 556.15234 222.16797 222.16797 ] 79 [ 222.16797 833.00781 ] 81 84 556.15234 85 [ 333.00781 ] 87 [ 277.83203 556.15234 ] 90 [ 722.16797 ] 94 96 333.98438 135 [ 350.09766 ] ]
/DW 500
>>
endobj
8 0 obj
<<
/Type /FontDescriptor
/FontName /AAAAAA+ArialMT
/Flags 4
/Ascent 905.27344
/Descent -211.91406
/StemV 45.898438
/CapHeight 351.07422
/ItalicAngle 0
/FontBBox [ -664.55078 -324.70703 2028.3203 1037.10938 ]
/FontFile2 9 0 R
>>
endobj
9 0 obj
<<
/Length1 37272
/Filter /FlateDecode
/Length 24906
>>
stream
x��	x��7���m���2kfz2����$���UH�H" "K@ō�"��U��z�V���p�PQ����^�\E���g��w�^���=�����_�>���]�O�s�Tuw@���a��*o��I
3f�Ц�M�(~��>qF۬A���2��&^2WY1��K�u�X~��)3.-|�;@��)m���� &�˔��_0wl�@�Y��S'͸��_.�n�=�Nn��3vl@:�L�:��>�l�x�Sg̽l|��@�P墙��<q���$@�3�.�%�2�
 
��m3&G�������f��U�� q�>k��Y_3����
pЁ�����d����
2�0�M�np��%��]��$H��gc����NW�}�+���h5�/�J;&X����:�ᡏ
���o�K?=�=E�;�����,��U�g0�.�v�@�"OY⵻:%
�y�L$�(yž�R%�'���,
͞��J�	K!��Ԣ�c8�т	��+pVa���]CA
��`$����ڮ~�oՉ'��t�5�d�<@�s�)�Rn'����k���P$�/���2]T�K?M�]�}�~���B�3z����M+M��A���e�%i]f}F�æ��}a�����V�+Ξο�6����/���������\��;����J�K�.p$wZ��`Q�8t��T�����6�I�Y�o�[�+���W=��9�猞_���+rj2�0�����}�<�
�e�\��s8�l�?�F��l^�����h�E���ɘ�v\���
*�u��P�<s1�0}N9O�HL���Eh����WQ�Cq!&bf�3q
��?���Gg{�m���P���T-��<)����Yl�ܓ���E��^P0X�o��x����)����NҴC��8�_b����\�V;e�v!�`*�jg1)�k���1I<�PhL;��-�Ƿå)D..Ơ�,�8�8�d���$����c����˷���v��v������
���vJ?�O��u�'1�DY�vc�B؁�x@�����Z�a�����@-��۱B|w	;p��DaЮ�
c0���ټ^�^��1�<ܘ��B��v��ƙ|;���|;���h�18�v�۱����C}�g�|��bVϷcp�N�"��1�����|��<`偰����eq���S�Jtf$H�����'VWۻ������WiIqQ��т�H^X	s~����q9v�l��MF�^'��Q���ȐV%mM���駗�r�MIF�N�hM*mJr�oi�J�F���2Ѧ$/�'�D�2q���J���!�$w
�()2nDSDI�<8Ҭ$���P-�\˛G����Ei�L�$I�Ґr�ԥ
��KK�Z�aPd�dCi	���"���%H�#��w�e����Z
����!�nHz#�I���mRr������p���$IM���Dd`�Z��`��MR���n����Fem���7�d��Zl���6�)ɵ5�>l�Iwdp�}�aϯ�Ғ�}P��S[���υ
+.]�XI��tjk���fOiIiI�i]:$�h���Ғ�Q���$]�ܔ$��KKv'�2�79��jZ�)I}d`d��i�mJҷ4�����|��f� |
���M�p��inX��ґ��{���-�%ke[F�k-�l�d>53�d����Y�q�I��Q�d�5�LT��I҂:&�a��:��fRZҘ�4���¤~P�R��g�'�9�,�I����5m��@�,��䤪%Iۉ|��8YT�TD����ʽKK.I�Hd���(�7%I[s�2OiI8���T痖��#�2e���!QVܜ���e���9���D���[#�Ғ
�ow%uѓV9��0�O����4Oδ7��4�פ4,m�ʶq�oJ����m�\�1����l��9�5i4�$1+4��|A�/5����t#�25D��[O��fC8�;OJ�G�Y���,��>ſ-��M�7왖r���|�6��t��7m�#���EmJ���ʠ$�iJrI� �n�cG�?���ZF7�����l�7��l�����igiɐȐ֥K�D�!K[���Ԏ�#�Y��>K�]:���������!75'�֩�O��	��	��(�|@�P?c8}��kg�~
 �=��XC.�ló�<x��
/����W�v,��qx	7`$FB�`�N����Apx���X\�N���9`���f�a�c&n&g��0�kQ��p1f��I�E�M}�`3���
#|���إ~%����R����m��H`,:���sp��u���/�q)v��P�"�i1��%���xȕ� �m��jR}h�T܃Nқ�F��xu��9(�e���X�M؄��w�I8�>��%8�
���\�{a���'b83����$B�Jg
&�RH��{�D��X<�
��|O��W�܋�u ,X�[���>$>RF��1�'�I��@�T��p!n�]؁���l�&���#�����>�Z "�{q?�J��C�N�!��Gt�@磊�����7�6pf�f<�ԑ�\2�\I�[��dy�|F��t:�����������v�Z�z�F�tS������J�z���X�[q�l�n��wp��@��B,D!ar��\A�&7���j��@^'��C�s�
���LAAE�a�G�h�����}t7�M_�_�97��s��8����fs����rn#�!��w�P)T
+���j�	�Y�h���A���?vu�O#�$�"�.�A�.x�C!�1mh�4\�xOc1�"ҟ�EF�	d�M.#א��=�����V���E���f�x�E{ӁtFϣ��l���F7�}�'N⌜�sqE�i\7�����VpI�U��w�;��T����<>����y������x��c� ��S�?���4\!�HˤM�^]+6�9l�3��i� ��k�6�Z�{�k�5�b&qCi=@W�%�*�����}i_r6��Qz;}����h_n(i$�0�Vd�&:��
�����o���k�F\&����kфuD['��r��{�r��?��xq�.�(7�ɟ��B��}x��M��F�~��D����q,�hRI~�Tp�ll@-���t�6�p)��N2���[PE�ħ�}��)\,�.�2��_Jd(���I>�'�#-�=�����nހ�ܓ�V��>�
�#�T��U��Յ�/4�o�)���q;��*�0n���x�a<�D
���B8�L#��n܃{pց�e�N���x
��4�)��LƧ�Jz$Ʃ���\�ކRu/�W"���˰�,J_�Y��'g	C�na�ZJ��w�(�������Oa�[���P�ޤ�
.�@���8�1_�c��mGU�l�V���|�F���!b�T�"�V<"	h��D`����sC�����(��ƹ1�sc��J�
Q�c53�]����s�֒���n�J�8��5�~�E�Z�-Sߢ׏m��#2x��>���Lu��\X������
���r����b�B������s!ɹ@91[�����+�q<G9�I��9��l�`�*�v��W�+�B��[l�+�I�iz��!p�=D?�b
=+=�zz+���A��5=���
z���a���~�z�
&����6�
��@�� ��Y��A����������{ �=���]�.}W�N����Un�2�e�L� �q��{Ne����Ǟ��h�RZ5���E��e[qt/d�
݋�t/Z�^̢{!����,�t��}XE�!I����/5�/5
�	��
嗖r�	���>�����P��^�C_�;�F��/i�U���_�/h�e��ѝ��u���
����@}
���|{H`��@��PF���n�0�
�6,�� �m4oݤ�}��n�N������tHL%��ΨL(D���L(}�U�TVFi"���ʄ�@���*
��n�L(D/_X�P�^tIeBa :iZeBa :nBeBa :lteB6�2Ex&�0T;l:QX�(��"A/�pz)xz)��G��vﺢ�P�ޓ(�Y��$[I�H���L:�&IG�t�G:�IG�tIG�tl!u��KIl�M1�𐎝�c
�h'Q�Q@:�I�Bj)^wF��4�~�+^߯�u���QO�X@�఍�������4�^��{��/�ϔ{���9�t��簌>��9�(�ϡ�>���9p���P�K�������/�*}"м_�h��4e4�4h�<|M� j�|Mà��e�i���,��X�>G�Ӣ�0
'r�\,��-k��AZ��v�Ζ"�Mߛ���=��.C.Bty/[�cn(E�Z��"w"��HQR��C�V��j���u�1������:����)�c�p��@��M��[Bo))���-��Ol
�
�z�,�#�B[�)Bօ:�ts�.�f�F�0�"��]�Ц�U��B�Z��L�y�)�$����q��7��%�S:�)T8/�P�f�l
����3٢��Pπ�i$�]����(�VHM�0�F��J���r%����u�΢3�:�N��:��ΙR&����(3���x-/Si�Y%:�3�tp��q�@Ҙ�>��+�c�")b1.)D�����&�S�:2Y[ܘ���۴��[��u�I�$E0�)ETV��϶66�ۢ���Xtss3<9��{���m�!��
h���_��7����QM��s���,��67&���>6�oȑ����?jn���'�4�d�\���͍)2F��B��0x3�57m��0:(�`��]
����3�ܴY�G�FW��kt<atk������h�
�5�v�r*�΂��k
4����hv�t0�d�$h�6�H�
�$@|ɘ_Iʲ$7�$�A�#��24�'h�77��4y`q1Y߷y�x�o�i��ihM�x�TO��|EY;�9��m=�T��&'�#�''F+k���7��Ys����0�i�������&�6D�7�?mxu�o���d_����ņ��U��N��7͵��4�W-뫖�uZ�4�/h:>�i�������h�jj����ȳ�k��7���Ƀ����9i�L�#���
�X���6�M������du�I�L�"Q<w^�<x.��kooo�;�}�<&�,n�O����!�h�>hL�jL֏״V���VvK�>'�Ɔ��=S�kTc��专��.����,῎��,Ĭ��nYOA2��\2�8�&퍣��0�X�M��(��N�I��khl#�����y�\Vs�8sV1��O��dj�;/\{�d4���"�y^�x��I{�ɐN�$Q�IT�D��!I��3H:p5/��
T��s�hEh��{��z��x	F�yAb�H٤����u�^ω�u`%�(I/�ƚ�Ilj����K�$��ċ�=2�9A�I�x��<����t��%�Aωzɨ7��Kz�Y҃�y�)ˋt�^����y��������	�����e�Ƌ^�
F�Ao4p�Ag4�0��U��E����/f�t�N���:����V�E��b<ɋ>�N�b4�LF����z��d�Ѩ7��/LL:����xNǙuz���΋�lf����E� ���+/`0�ʋ�?���A4^X�z��ˋ:��{�+�n^ ��63/����b�&���f��l��E��h5[Ͱ�Mf��l�x1�`4�����z^6�F� �f��	p�df��	/I:�(��)�4n2[�V�Y��F��f�-�ZL��ba�LF��$�o�e��h����h5�^�n^<n�f�f�dA��[$�$��I��X�l��V�M4�f��!�&[lV�Uf3̌5�bD�贘-�I�mF���Nj���l
Vx�^o�uz�ΚM�,v��i��:���v�lp�e�-`�3�V��j��VQ��9�L�Eg5;L�K��=��
tz��C4�6o�٤�b�1�r�v�K�:d�����p9��ƋY�ʲN�%�"yٙ�N6��f`�}�E�z�ю�K4M�Q��g�ƭ�����v9�n����^�.�ۥ�\̂`��&�l�]�d�o��lFYo��-Va�}��p���b�#7G4������'����m9v�ǗO�˓��+/v��f����n7�/��/&� F�a�d2Yr&���M���:������\���u���^��n�7�u�`0����r\.I�B�L����m6fc��3PT�&�Ս���b��&����&�[����/4��H0@0���
0�w��v��f��`p�ٙ�����q�����;���+�܇�Cϐ�j���V�ٗM�~?
�á@~���
��!�C�p�W(f�>�|n����nC��iu�}���l���"��Q�"�(	l6G��f��	�rs�p8??*̷xÁ���a�C���p�
�@��^Sv��k	x#/l��>^�@MMO�jsQ�o��]��n��I���������B�??XZX����pa~M$慂���5�k6�ͥ��`����}~�Y'�'9�>}J��RP]ht8�y�C��l�$��FJ����JYQi!�
�
�D���E�UYQ�根���ȕ�ܞ
?��ߓ������#�S�x�9'�W��q8
�I㶰(--//�Y]��+-�-�.Eyi��ҁťp8(@AA^A����jͳ�ؙ9y��p�Fr~/n���p��ETi�zsK\^��(����))aZUSS٫O�+ZYԯ�O%j*Kk*+*�,�EEѢ"WQ���ճ3�QWQA��x��}���Q��non/�Y+J�;�v��&���r��6��w��j��E��:^;����{�W��^�<�z����ؙ�"w��}�
�^�>^r���6>_�
#��C��_���&�ۚ�_���՝>�׫_U����a`���~���f�U���UU寮r�ʜC����C�|U�JKB����&62W�_��A�p��O �e�M��t����}z�rPݨ�����?}�ā�,�uu�uu��u99�9����jÕ����**μ���N
r�K�J<—���A���CM�i_�f��רv3Ǯv��E�E�VX�nȰ�ݰ��g��z���p¡��g����7\������/�������?|�Oh0~�'PDH�
r�FH�yP�����|��P�<�D��~�BD������艨�=�4X�B�J�C=�R
�B�ze(V��7��c�@��{�N�U(S�C5�գ��T�GQ�*�(�P�~������-�j0��[�C��-��N����� �>�7���7���
!����O��_���^=�ӐP��tP��T��L
6b�zga�zC1D�gkpNS��p��~�8C�
#58
g�_a4�.���j�hp,�V�Єa�h�p�K��p��b��%�c��%Z0Z��ip�Q��V�Q��6�U���1V�Ѭ~�I�~��8W�`��9�hp*Z��q!�S?�4���c�/B��9f�|�3����fjp&��b6&��b����]�s1U��p��	.�4�\�i�Ǹ�Տ13ԏq9.V?��3Տqf��j�Vc�;Ю�B�U��Sٳ�Kԏp��R���e�!,�|���r�n��X�+�q#�R�&\�~��q��!n��C,�B�C,�B� n�5�A܆kՃ��S�v
ށE�
��b���� �����
�
܃��~܋���7��q��-�~��2u?Va��b��
­��#nS?�����
������P�ãX���ոS}�i�qܥ��'p���Ľ�{X���p������{H�
�=���X���X�U�؀��w�T��&
>��շ��#��،?�o�S�[�Z}[�����շ�
n��[؎'շ�W�Q�³xJ}��iu�GR݇�V�^���S����^݋��A݋�ب��+ؤ�ūxF݋]H�{�6�{�[���S݋7�U݋7�gu����؋��o�oئ��}خ���4�6�U��;xN}��y�
������>���؏��8���xYݍ�SݍCxEݍ�4x����1v���	^Sw�S�����4�9�P_�xS݅�c��_j�{�]�
��W�5�R_�
�o�������o��*�j�;����c�@}�c��
~�~u'~�
u'~�Au'~Ƈ�N�`7>R_F�՗��c������|�?������n�������O��?��O�ŧ�;|��>}�o|�G�������ŧ�|��S|�!ͧ�|��S|�����j>�����7������{�ǧ��O�o�������}}����ǧ��O��>���|:%��H���H���â��w'������Ô�J+�'w�^���������q�ǻ���xw��<l�
¶0
��
��xB��P���K�$@�	�`Ǯ
)�t"������
��#��qԉ}�T!��b0���S\|�|�%>T��>|X�
��C��OG5�x"��xsE���U�8�w������M.���!������w�b\�ǭ��j\1o3���>��ZH�?$�=���A��<����=楐tq�Uߡ����=�2[���	��)I�m��k����qX��!w��5�0���q9Nl�X�夸����4��rW��ʹ��}�H��d|��O�fa������u�T��s�X�3�g;;?䊄���9'�hcO�e荒�7�$�c�J��bmn��s�-9��x��c�Q����~C.������c�6����@��f���mq��-prd��&�ȦD��b6z�=���i��[$Q�hxn7�o7X��0�J��n��o� �n�h�) H��+�Me��R�uX>|e����3P�w�m��xw|�Ы�*��Ž<Y�)U�����nG�w�#�;���Q�paW��8œ#�O�؎3�_���+ƒ�c���F��~u�1���#}�/x��w��w�5�Q�#}��1���ZO�C���Nq��F��G!���0,�.�ѩ:���^дz�N����^_E�}+]	=�]�0r>��#~�������EW�+0��{PL�
z���'{���"��ޓ�3�ͫ;N^��.�X��.�wuw��VWw�I�[�	���3h~b$��,�J���hqe�!b��ܼ+Dlk�+D�r{�He�G���
�<�+1�H�`
�h�)�C���aȉ�B�⨮���q9�H^��.gNUeM��(G��m�>�b��g�_���5�8�y�@.�����s��g/ZK��ʆ�q����a[��/���{s��{ni��]���=���X����{o����I�/
{B	jH��K�����q_����s�T�
t+r��Co(���^�.L7�Vw[��9��=|7���s�<�?��+r�R��~���zmp�B��
�W�鮜g������^XәC/tO����Ș��5tHո�3�O�}�������`i/�
���\����(��R��P�)���>��}n�V�,�*W�H8����e�I�q���p��Kr��z���L̫*�S$"M��}WVCZ��-��v��G[Z��è?�Uߵ�ҫ��I��bCr\�h��/	Y\ ����h���(��P
���-J9n)Jj�XF�qu"fǗ�����^7��&�}��m��Ի�|���3��y
N;�-!Cӛn���kF�Y3q�]W޽�Qsnx�s��oܞ^�4���+�?w�nQ����	�
�k,��M�{����lǭ'��o�&\8"|E�-T�rB�4�yi&�g̃M�	/�9`�wߥ�����U���B+�l�t��"U�ҢK���MZi9��)�=i��&���ǘ1�>^gR$Qj�����%Q]2!�xm踭�������b����_o^�b˟ӡ��O��z�2�d��q`X�Ɓ+�󬖐�Z�����ت���ªw�K��Iqq^���n7twz9H>ܺy��qo����W�o�:$���o�xp}�L#1��o�
z��*�$�H��}�-��tn�Y�D�}��}�m6����A���8�s�(����"w$��#H���zgݔ�0��>���x�,nw����e0C�hq�渣�U�tR�
E���6���t��sNY�k���f^�gؙu�̭\ȯ�������.����{�9Ö�|�9�zyٛ�s����7���D��:�bA�xÏ�����zM�ò�c��xW\>���h�;~������U�®����l��q�,=��ܶ����A�xz?��`��
�'���j�
1�8�#\b��g&`&`�2�xG>�r��ܥ͂]�K�3>����w���$PS�i�𱕱n׮�7F�z�������p(Ixg�YJ�RJ"�>a����ٝn�?A�Ю�r�&-��a�ړ�6ndR��b�����2f���
��3�E��S��X�Eؗ�4&�
�Q�����9c4��O(�؝��J�i�r��8
B	8��@?#)��F�_����]rF��|�rU�3�����t�W��''���Q?�m�v����
��)��:�����*痵�]=�z0q>/.�K�K�/[�d���Y�3�����]�#�ӥ�Ɖ��\ӽ����R������]�
�eϻt��������3h6����p��\O���T�<dkg1N��T+H�bypǍ� G>�2��	�����F�簤���!ۙ'ͱ�d��W�̼�M�F�$��{V]�n��i{�;��͏]y�c�]}�-t�I�''�O���������?}��G�T2���gcq�?�a@{B�X�:�_@�ѻu��<�C(������w;�#�|&!a���8sK�Q��@�����"d�hvq�vo��@=3`綠�8���Ի������a���w*��_����S������$lG�&j�
}�-�6q��C�r@:��lm�n�d��~���V�Ǿ��G|�m�g�/�\9(�Q�@RB��^=��
�Nw|�@���8Bu�g�)���a6bK�Fs�) ��[VBM�v����$[�B(�I]�d�XO'Йt
�i'�G�,[�Pw3%Ֆ?�]�-�m'�׉�5c�81�uh!-s
\�h�/�{b�d��	��ۅ/���?���껯��>����{������Y3 >q���|��?ܷԱ��/�4=���%m �~���Q�=��9��`���7���.�s#s.��9'��3�w^o^����� (��h4�-�D"faJ�`a'�I�
&���t҇�S��`@��=���	�L�*R{T��(AT����RO�ԭ��!��P�'��CI�ܶ��=�Z�і�Qt��ce]�&Ȍ+�I]S$2�Q���#yR���	�1�I"��!t��O?tU�YN��=u��orn��e;�_0������U%�z�^������ˮ�x�u�)wLY7i�}���e{��O@���,t�3�&j�M���{L��^6	gqg�o�9;�:�DNFN��d6��x'���d�%n����Y�0���+�;
|�^�� ��jC��&�R"/R-u�{K˭�Y�����B9�ђ"7i����X>V\|�8."k�&���b1�
��̚���h/ʛ����1sJݛ0VŸ������Y��܂�A�NS�3u��ј)/3%JcZ(���{�*[�+b�l��辎���_ܐ�M&<�m:~�#�)O������'�E"��7?wi�
ǣ��L�L��uz��R����B��S=N=������i�:-��jNч�!�JXVY��bM������g�<��t3E<��m��y���R�G�C�G�P�rž���
3�[g����1�[}�U#٤��r���+k���Zؾ�b]�b�*�yhV�4��r�b�R��-2k�*�rJl�sΟ]w_t͆57����c��w��vݭۉn��G_�&����u��s�?�L_2>}���;�f��ꧼK؎\a]�p��������8�he:7I���f�����,�]اۛc�R��
�JD	3˶�&����lv�ɞ	ں{jB/�B^�i&)R�pacA���N&�m5*//10aI,a�wOp�t/p���__��ͺNH*k��ɖ�t�3Y)Z��^��,���[$6���+q�"5�����3��p��t��)�/}��Ӈ��5t����9?t���,�ʇ����������\�u5i$W��������<ޜz஧�fsJ���ŒY	��f›	Ou��3���rJx����q���0��s�gյ���ad�@�z2��$O�����Xpv|�Ѯ��cl�c�	��1[,��6��Dp����k۸�7��k���k����i�Mw���S�!_���Q�������V�Px
���b���D�
4^�zP6?��ƅ�Y�]rf	�YŰEL�*��]�vqͻvt�.P�!�}xQ��i�BA$��G
G
8*�XPN�J��R�M�OO��L�{8���bqg\�+�i�W,�
��}��q/��;ou�����g�ߗg�h�K�:�2��p�@��q�#?:n�� �d82<���
��E�t�@�y����I�����.x�|]]]]�����j�����{�7G���+ta�m=�'����vB��		LL,���)���Vy	�\~YxQ�.��:������Ƥ���[�=o�ͼ�3�ϛ��(I&���D�DE29%�D9N�MN�7郂������z�L�'(���A�1a7)�,q#���<��'|���q�i�t��-7+�Vi�DH��`��Vf��G[fm��钻|^��������p�-	�~�
������?oy���BW��ƤqTc28b\����N���d&�L��n��*�؆��T�z�6}�D���C�q���@�����5=��#+6_z�����?:a�<���p�� Ү�N/^�'�ҷ��5��9z�SX�����`QQϞ�)��`��'*�.��|%�AE�8[�������|lh׉�*�����&`��ƶ�H&<hAK�-|��o���W�H����O3�4�����,Z6��7��@�-�;�q�5��#3΋�g�7���͛'����­SֶVp#m9=cfϟWI���CFί`�~���p���H%Z'�i�TA�y"fann��]�{�'�G̛�
���q8��\�Şk�������:�<�9�5�;U��{��F�=�ݖ{���t��o���N�dz�Ӻ1¢��1�
��A��z9j=Q�Y���������+W�Z��p�6wf���->���H^>�]mϯ���R�9c�rڙk�7<�/���]��}�z�}R�w[ճx��3>����(���習��������+��n{(���[ҟ/�
����0N���.UBd�.3�69h��U�D����q�:�
��W�������N�>��E���"�.�l�DW�3ǑÉ~�&v�;L<�@��lah[���DSw�;��rR��+�
xa4~���ĸ��綟}����גح�T4��פ_:]�g��������cm�kj*>��'��<��?"qn�%
A��}=dz5�F�$6f
�^-���T��|f^��kS�s=����=z�����<�ѐ9��?��w�й&]�dڼ�q��	�У1Q�q�L"'��N�O���R��d����Ù	�M����j���d�p�k�5��`����Y؃��h�;�.�ZH��9����G��RBDw�…����haA��q
U
[)G�t��ܨb ot�'�v��r�=�鎳�B�]���o��2k��o�O�#��/�
p�)*�������F
<��0r��0�ٝE�
#O(���&N�;L��p�\8���&�l�!~��N�5h!�l����ԋF��Z���U�5�6�,:cY��Uo�WnXO�����ۢO���4sѳ���z��G���'I��9��yo�#���n/��1t�uÖ�|>�CG[-���|�4��ʢ��B����z�*��j(5�oI[:��L��
�M9\�h1)f����[ͳ�|�fOq�l���PJn9ז
��x��L�0R\���lU��-l{�Y�ӳ�v�Bg��踟����CA�
 �Np�}#�'�v����v�WUgpiy������
f�Ǘ�M(3�Պ�\xZ�8�˰
I�eH`8���eX���5�0h|Ӻ��<{N����8�%S�*۶g�l�Z�S�M���&��t�8������D=%)�K���U�����Eqőpw�:x��ѾI�Kn�}�Ͷ����nD2�X��VeӢ�hߧ�YϘ����^��]d�g���گ�9�M휶���
@�F�,JTpy�1��O���Xc8�0���{��.1�ýc�z7�K���/t��'��}<{�x0����9�����)fg����j]��jx�z{�ߟ�����tz���(Jz�^g8�W�Sz�N�D�$��*u�8j$�S�O�Z.�UBR�.x�L�3�KD�:���I)z}�hT��l��tu���b*3�8S�x��X�Y؞�b��G[�J:9���ƤgTc�?b\�f���u��u�C�M���J�1�y���R�oʉ�y91�ݨ���9c|�c7�� �'\�S>�nf�Mf�i��bM�I��0�l+��o��nz���cG������E?�"�gG�/Ҟ'T%L��\P�Na�}4a�(�u��)��'-�Qʰkų�M��o׀�.@�
��ɼ�P��I�:�����L��t��+ד/0�X��s�K̗Y�uF*�b��0��
�����]�nn��B��{T��j���)Tg2���St��֑$A(���7��Y:=m�wة�����T�]�T$&�AI��������	
McBo%P��d"��g�U�8!EW��1��e[�-qOw<�m��N��S_�<���|r��.�J�`_�|E9~
U���3t�>Pu��6&M��=41�?��Xmvwc�p�R�v86��,��Zvci�R���(n�3����wM-	�"6!��H>9�<�ۛL –����MB����z��{��?
�_��7�g���}��f�/�ڍ̋�v��ul= 霒�����<�zI�s�(
-��(���V�,c�Q0��J�M�����qnŚo�}��s��
�Xl1�+# ¬a�.1$ƥ�훆�t��L�2&�y�
�Mޘ�W�ɲ�Hf���IgL�8X��&GL��f��1��b�֞����i�bs��������������B���?
�;~��D�S�a/,�cA��g%N�����~��y��m��7Y^�pn��O�܄m�c�;�k��c�sl��<c|c�7�零7�q��Q����\�k�2Yy���-,�=u3��e�CF��g!�6c�ʨ����F#y�H���WȐ'6�7m۝�\��}�=������ߢ;�r���G�?�^��%2�/��ӻI5�'�?�?F&�廅N����D�ɶ�N�(7:ϕ�u�FS�j����D[��Χ���#>�9�#��.mf��u2��L�ٵ�;H]N�l�ʓ*�y�Ћnk�*�rz	�b�-gU\��A��'o��%���$GnZ0�Z���䑳V��B�5�q�t3B�=�Zo�U�S��y��6V�-���ؚ�������h���˴�}Z{���.��8Se�����2ߺȰ�z��1k����S�l1���i�YmV���a_�A��d�I���9n�7�v#�����Z-�`�r�آ��������<Y�E��r"T�[�y{�N����;.�ce�|f�]8��(�2{�]���}l�>L��l͍X��	�7f����yޘ%��yΘ���y'-�����;��p�ha4�FJ��
?H�>���;��q�Y��gϹxli��C��g���t��9�����-�?{^z6���:��=�����T�y�x�S����#��o"7�o���|Aao.ĝ!����?�p�,�������9�O�‚kudpAC�8eL䜂�����-8'{��?��	|SU���9w�r�,7[����6����z��
-��Te+�Ҳ��eT6Q�3(����2
�-Pǎ2���60�¼V��ax_�$�{nR�q������'	&���s���}�s�;�;�ʊ���zb��I�,?���'������=7�H������M���@�Eh*���!7t�u�~
�����vH��0��rs�ۏ���(�E�y!
����pũ�=��8ʼn~%?�;�n�*0��i��kU.*���a603��8�n��n�]��<(�zc��'5���mb����]?���/>��dl<1������c�������]�l��y�͑�]s��~v�;�,�?�����򅅃��\ql��e���|R�!Q(�$p8ES$�@˺����A�Q)
���a�G˺��3c�������nm,WaJ��T�9塤_��lO��4ch1��<��ξɒ�t8��h�̎"DZ+����
Rqb�Ks�����hp�&�RG��pHf|�?�Y�Q>n�k���8Њ�\�L��
qX�f'P��5]^�lzmv��J]\����~t�:|y�'�˻��WD���W������Q�f�OcL)�A!�K�2�I��n����(���H`�q~���, �#ʆ�AD}��
��a���_/�X�ƶ��ř3	��Y>�v ��;��j�P�D�S=�9��hc���l�Ki�Z%~8����v�u��N�M��&Θ�	d>���NN��am(��.S<����Iu��S����:�<X��1�!�|��pm_~?��h�5��ۖ�^M�q�f%���cD�EZ��jL�t��ձ�h�t0M��Ms*��m2"H�B4ò/�"��mVM�;t�ӞH�tQ��ǭ���5f�Y�(�S�Yt˲�v��nwj"���5�ݮ��,�զ(�Ɖ��Nɪ"D�E�p*��q,�DNMSU��uݭ��D�"��p"0'��T�˕������n���ۙL�]I焑sF|�c��F����j}������?n"�攎l�(5G��]{�u�w��;��N��(��aY��2q��.Ѡ�Af���f:Ъ�U�rXqz�_���㩀{���\_������/��3�-�&u�r�c[�	�&ݩo�q7���(2��?g��]}#c,uX�4�(�At�H+��U� v7H��ThUV^��O�K6ʓ���џ���}
�*�J@!��)�-!���f���c��d��)̰L���9�v��l��� �`��J[e]Onf6�[�{P;J��~L��=a�H��<Þ�|���x�(�o�@�b�-�ER5�U��C�@�V^����o��3)�$�/6Q$x�#���$��-�C�����!"1
g���|O�	��?+;�OwJ�rL!��e�~��_��c:2�<����s����x2�1����k�#S��],�el=5�k���ɸbWpF�A��A�8=1
gd=1k�!�3<16��|p�G =����axc�š�X5�>��z
A:�!���k1���1'o9y5��!�L��C ��5��!�~5;�c�2���xK9�:��Y-��R◐�T0`8��L�ȹ�C��
�T;��~�ڸ��a�/9��H�Wѐ���Ό�y\��,WM���D��.MǦ��a��(���(����U���̋��μ�"��b��B·���§4���7F�Mp~^��@4G��!iQ�!��ep<�
֒@N����G|�7$A����=d���N�W]�
ɒ��x�=�$3�xݭ�l���p6�k�#6
�dVOˑ#u���/�MX�����H�7��FS�2}I��M仰
|�υ�ī���W�BE��o�F^w��g� ZD�O�Z�fY;�{�+�o�O5#��g2|$�H��`4!��CRAӭx�}b~_�GI��ʭj��@-��8q"��L��É�?&��7��b �� �`'@`%�lxl��X	��At�>+#��+�E�(Vj�����A8��ͳ�^��0�B��MQ�!� ^��B��s0��\-�ȃݩe'N�R�[��V�K5��S��
�b�
���î�+�yv�\��g?�۸��K��
�rW���ERqqL��Wy���ǥx�����l���藎���I�ݮ��^*<�:V�g�'����>g��8#c%c�1%S���\�9�R� �)� �Q��H*���>0��U��yK-���,;,i�ò�򽅰X���@��V��ˀ�a~���nVn��@�h(a5�PYho�

��3JnA�,�C;c0�����W�c4�ѵ4�¢<��-���$?�{v�}pM��lK&�����ԈI��v���"��C��r;��-4cA�������}h�ޗG/S���<X>r�ݷ�t8ߴ�����_��Y2s���O�r�2��MX7�f�܁ ��ߐ�g��u�����>w�!��'�^�p|阦뇬�O�!q��}/@J�T5��j}>���{˽�y���}t���Q��q�;�ƥ�r�q�{
{�4_^�X���O�']�i�V���Y�i_���S�r�����
�z���K���'yQ����xi�v�Ep�P�IhHa9T�A9D��v�v�s���ZX	��]��Z��q�9-��]{�֔/3�HK+h�+P����Ȯ���0aӯ���3ݭ�n��b�����Qt��+_�͊�/P���|�������O}�|��)�������g���P���9��í��I�Iz��I=N�RzZy�-���_����
q��&��s����׋�!’?K^"�-2��:����7���q�\vGE�+0N/)xe(,�A@�� ±^{�}L-��
��s�j�Ik�V*������g[��5V��{�xo_@�@5Q�+Q�I�����~����~������u�=c��O߻�Ax�~�́�����g�m����k?�J�!NeU쏌�򈔂RT!Q�
�44���6�;ͦ�p�ښ�=�����>�~n�^����iA�/��fW��6��G
���UHuh�4�6�;��*͓>��t\��-
�A���+0*��^Bp�CT堢W��j�ڦ��r-�*s�9Ť_�z�`\�ц�a�ǩv�
��5�7��jZxP�U�A��^0���]��s��W,����GK���V��ͳw�~r���\ڵ�'C������[�?z�#���2�
� |j��
�M!�T��"�!RK�9�*(���.�.��
Z�k�w�6�=�;Q���{���}�w5��~
]p*�
eI�8\%^�]٩ E!=^�
��8���%�0�*.\퐠��a�#�����3���J�1��k.Yv,F�'{'(-�ȅ���&�|WM��&��d]���>cˤmL��<�i����|w�����B�|����-ɓh�8h�5�����n�aa�������p����w�����S�>�A��k��*u���R��⯤�$�-J���gW��EsX�e/�(b��
�6hK[
R��@�@3��5`P��1�^_�@���zy��
v��̭֘\��x�)�kL�h�6E�9�fiD+��
*-{`F�׭���8h�+tyE�
�ct��vLv��au߳����Aoq���--���iO�n�ry.@��D�kr(�����$��DڮF�h.ǕS"�l%1��6Ne��L���-�J�C������,a*�*�jKF	��FMΛ\��ܚwkQSI[����
�����'о�B��1g0�����
��[�Zc�����|��;���r>�tס�z�ަ��rA�/�|L>%�e�'���2!�"%�����L0�y��j�i����"����J���A0��0]��2#S��S��Ϲ{��×�����=���^�c��������w�]��w�~v�{bp��U�ÚO�A�e[���sl�o���z^}����6@�13I�
�J�z4HV#��i�
��YUTm�����A�(���9��An��zң���9Z����p��قYṼ2z{�~��bI0�>����Mm#r>ÿ�d�@쀛�f�-L�B�(��֬�xF����j�j^ڮn辫g垺���'��H��_%g�'7�9���ɗ����5�V̀�F��k�vr\w�;�1��qK�6nG���\��}�!���]�M�4����Iv�=�i��!ϑ�~�8y�$�	l�����̮-􌷶�`�Z�n���&�9v쒝]:�)��Ra��5��ORAj0YN��(��(�$IY
�D�DR��.�f���n�6]w����v
��Z�^ ���b��>�4��	
��[@�x�{��ĕ����oP�bca9�*�r�2���B��0C[�\ &Z�w���W��*�ˇ=6����~�s�e�#��K;����g���cj��n��J��Y�u�&��x��~�*����8t<׭��e�af8��j�(M�IWq�I*H����I�3��M�:��=����F����4rk�۩��Q���Gt/�����]�y� H�ep��y�c�`F�&H2��y�&H"�'3ò�xߚ��gP6
����n��$

B�`-��D�oy��^��f���/םMF��`e��ڦ
nV�)l
[C���m�\IN�csrj��ݙ�u�:�f�//f�zfȦ'�tOg�)v:p�i�b��J�h6��>=f�u��6G�cm��@'�:������d�wo4�US:7�
���>�Uj
|��ԓwS�/�;R+�����A�XeZ��C�J�tU
� ъL[6 �f*�{��]�ʔ��A���z�u�"|�R��JS$�V*3��o2'wyEt�=��cĕY��2&#�̨4'�V�L��ӝ�D6@�ȡ�=��_�a�
��d/�7�s?�!u��t�_�9=~� 
r���+4��K�a{pgu�m	��e%���`�z0n�*/���1�`k!�+L��]Wjk��d/�P��'�VKk��͘��_K<YD�5dU�${�ti�`LߔHt��Ĝ3������Ɂ��|�w�[�~��`�Х��>��u�dh�Y�L?��@2���mV�֧����ի~�p�Dv��
��J�=�$�ψ/��V��cv� EoW�6��3�$���bsh^���C����
�\U��0�iv$^U��h�s�����$�*�;�����E�[T��d"ݖH�N�OqW��r<�3<A+!��x��k���1m�^�
q��`�Z�Iӓ
�]�p̲g��c{G.?pmrZ�xѰG�Ib�qD�&�	����.q4=��J7���f��*�Z���9R���#�3���
J\�;np.�q��E�"�l�*h�hJ���LM�oo#�Ps��D^����[����`����Q?C0NaCK�.��z��F ņ��7v|3�g-���x�j����$jwuG�x��$�A�ӿ����?�:����S���:7���oC'����+SK����`.��y������[�
�f2�
4����~��N!k�~���9�s��Y�o���z�g�>����(��gz��fe��������������������Q@F�����VF�����79)EP-��u����
��|�Ɠ�rh-G�Z���FW9Ή�̀]�]�[���nåz��J\s�6<]������8u猇���W���3˗�K5S�l�8qKzۮԥ���N^"�~��������1�f�49(�~glP;�:t�H��k]u��ܝ�T���掰��L�N��j��Ӕۖ�
�������S)B�b�C�X4J����	���_���\F2$%��+0��%`�-�G�2TdCn��dR^����3'�G~n��=_���Z��
�+���BΒ�Ǧ���~��w���d����޻rŮT3bO��!�3u��/'^|������G���}���P��{���V��������I�\r9Is*˱�dU9	,L3<W��B6�o�V���?�Tm��+^j�?ߊX|R���*����b2J�VLe�?�0�]�視͵7�4����d�%CO���~&<���5�
����3�>r((�'�;�|[~57���?'
� wo`���%����zY]�G:�ASRB�9�����g
3ř�v
��_ ,Hݡu�@Qe`�(��.\^�<��9�+���J��=�?'�
?]��Cȑ��-76�
E�t�CvR��Ɓ���uջf�����h��s-q�r�>�C.�z	M��9��I�4��C�һl��	��Z�(��g�ܖ�r�v���|n���3�J�;�@q"�s�;^���B��h�����v`�@4P��? 矺�\
��[����	椏c��l��E��F"�Vs��^����R`���P����h�U!�|��
\!�T?�sm~ȳx@~�$�E��9����Sr𢑁�̓)�G֭�QJv���C��o��VAw�`���vʛ�\��"����
*~x��Wf���5�RϽ�>6����c'����9#�8�Ǯ�0��B_d̝�7̼����c����̜�c���鿣bj;�A�!�c�657�V��� ���C8."��K���E�fؑ��&f)�ƴ3$`��N���a�34s-NX�onf�������gk͝Y4P(of�����=�L�Ze��$
R����r[ɽ�v��o��>�C:�)t��ܖz`K���K��\�I�!N��~�p㼏]�"�Ձ
�sF�f�F�0�Z"�:�@�#��MC�=:�'��a�]�97Z����p�ݤ[rW&\���s�9�������.j�f���&�-�~��&�$KX�Ǖ	���H��	����e$�l.2(�*@LԮ��]���-��'N|pp����,��X�Iv=0`��ImD�K'q6�����M+(���G���8�捲��鯻4/�f�c%��͋���<�������įN��G���T�@!�c��F�S�T��N��¹��m�V�Up��]ͭ�7�
h=����n�۸���S�+� ����?	>����y������*�<G�#J���
r���x@ ��	�>���R�"�Y�02�/A�~�j�����#�_���ݮd<w;��Ƴ�qW�/5��C��k����[�!ܓ��w�A�3����b2��wޒ�+�F�g�уdhh���6XL�h�z���J��>9_^T��d�[�E_ J�"g�=�K�H@�'XXM
V��xY��c	� S�F,QP�T��-#�Ѵ��g���hu�v�|�������n��`������
��%�PPA���a��6Ti����6�1��,zV�-��Ö7ȏ�����v���y5��I��yVE^QU9��뢀�O��sy��]eX?�jZ�bl�XxQJ�$YXU�#<k�y3&�^2�ʪh�x�'	ME\��U�1)��.(�
m!%�3����n��)W��%��*F���B�&3$�|f?�`�0�\\�����d�%o�w�{�$k�y���K�~8����G]�o��n�/������OK�x7(��Z"}�m��X��4�`���1����#oR]G��s�����]-<c���
ُ��M��w2e�;� t8�/]��+���ϩ��]���.
�,��(�bx;�}VS��D�&��ܴq�n�-D��u��?WK�?whGŐ{S�/=W�1J>ޫ��'���.�{�$Z���1|�M��"C@�����]��+6C~�|��n���C��=��2'����rvɭT�ja|P`K�id#�(L�<��ۄ�(!�!�eyG9I|Ƚ'�U���4�&2�	͙؉,+�:�eI���(<-#�W���R�W������r'�br'|����]b>/�Lsw|zt�f�r7,~�.�_ ��9�����[�γ�����?AL�G�Y�g�1abb%G2��k����<�gN�D@�����Lj|�|ݙS���=��b��R��hƬ8!�9�TU8C���Mm�ۮ�ޒ`�ǩ������N}�
a��eו_J��?�q��8���R���p�
]���W<�ڦ�{y��²����iɩ����*�J�²]
�B�G��hm�7k��f���J�v�������m�u�m����z��5���RR�����j�,*���p٬֠��4��EY�oުi�(Є�%��E��W�ț@��e����l����Yګ��2�#=<�+M�����z�h�&at]W��������uF�.%��l�N�T����u��Lκ��Y�pb禯��k�v����P]�eR]�s��/
1}�3��hKz�*��W�,�������%���)�(ƭ�,PeRg�%oR��mpI�]
QBj�k�D�}�ϺS�
���M�{N)x�9dar��ukV�����{]�$�ϱ�D��z�;��eX��j��,Ѡ&X�������*EUE��GS�����Ԟ�puhOq�,�@�9�t~�ڋ�K���M��h�g3I3y�b��������܎}ao	��g����
�±�7��
3(4u�o�A�_|+���tK�1م�7�G�Q�f8�b��!
�D��RG.\ޯ�+�Q�����5������lij"j5�~ޅ�.Y�%2m(�>�%Xp�;#&X�z�� ���<���y~�Eڣ������Z����=������l.y�
����U���UP���݂cA]PPa
x�͆C!�-=ij����)Mӗ�D1�^4{jؔ꬘2g�"<Qw���K�V�������'��_��mj����8�O�
�;8ɰp�;XC`�8�o/�ҳʮݯo����[�6�ߊ����_47o�
����g
endstream
endobj
10 0 obj
<<
/Filter /FlateDecode
/Length 322
>>
stream
x�]�Mn�0��>���"�q �!�P$�Qi@�Z*�2΂�W̤��F�x���آl�����G�t��֙�t
��X���:�W=v�����e�06��X�s.>a�s:��&ރ�`����e�a��z�#��%+
n�g�|��[7(�6\�qٞ����x�
9�4z20�NC��,�Rʂ�u]�g��g�����kwR<�rw*VJRV#e/H�g��$������J*�����0;�=��D�<"%'*fXTd��C����\�����%eUT��)�d9%yF��䖕ҭ�Y/�>y}

\ě�i�s���O~U��/#ҠT
endstream
endobj
11 0 obj
<<
/Filter /FlateDecode
/Length 1220
>>
stream
x��Xێ7}���s�*�J�7q�,��&)�l�����d����q��]FGytDR�ĩ�9p�~��O�f��q���G��Im��8������o��o�}�{ɣ��KQݷ������r����b�A�[2�߾w_�>�:&O��=.���8�}�����GRtL�A
�R�!D3ǘ|Jr_��1�!����
�qRq�䙣�c`)�`>�!;�������y�j��8M8�xXfӊ�	\8t��~X5U8[��0�W4[�C�
�&�=3�3�z����Ѽ
��������x�2��Ah��4�Ah�I��'���`�*2K=
��y�sy���r%�	�\ҕ�?������W�-�/��=wڝM|(�wo]m���{q���k���8����%��
(((
�h��.����������`��TE�M��S<Gw�,��2�MajJ�*�E�&�ƾ���P&E&�Iف��ý�X$�-A(KY���BA
n�n�mT�pA�ί�b��;���O�	��qC��蔞}���1;��	6� ���y�#muP�S�y}H�$y1�m�gu�v�m������)���nE�o${Uߧ�v
	>��OS����٩��l�x���G��W��f{
�2C���>-6M�!ojݴ�)^c�.
َpǪc�m������%vk���ux����~x������5��^������&?Z4������2�����P��=����75ex2��(���m�ڀ�n,�8�'oΊ*J�&��}�fF����r�\w¾}{^�S=Y�g��/�m���F�Pm�m��t���Ⱦ��I��-3��i*C��w@���]Kۡ���Zb.�7���D����
OG�Τ^���l�Q�I��u��9���Կ�^
Pj�Y|Щ&��go�C��l�jn�����מ!���)�Mq�3N:�ZU�����ו��A�5��SY�ڞ�$d2��D$��I}F#L���J>���R�L�Le�*
�z�u�����pS\���K�pi��d)��׎�~"8>ئ&��z:�(���쳝�Y�m��(�G'��0	>�	ۦۋ�a��@�U
���ͩ-�֩����.�����gVcc�������ah��K�auR�Y��D����Z|�z3���%~�9.�BKS��Ի0����K�|q��W'
endstream
endobj
12 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
/F7 13 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 18 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
13 0 obj
<<
/Type /Font
/Subtype /Type0
/BaseFont /BAAAAA+DejaVuSans
/Encoding /Identity-H
/DescendantFonts [ 14 0 R ]
/ToUnicode 17 0 R
>>
endobj
14 0 obj
<<
/Type /Font
/FontDescriptor 15 0 R
/BaseFont /BAAAAA+DejaVuSans
/Subtype /CIDFontType2
/CIDToGIDMap /Identity
/CIDSystemInfo <<
/Registry (Adobe)
/Ordering (Identity)
/Supplement 0
>>
/W [ 0 [ 600.09766 ] 2959 [ 636.23047 ] ]
/DW 0
>>
endobj
15 0 obj
<<
/Type /FontDescriptor
/FontName /BAAAAA+DejaVuSans
/Flags 4
/Ascent 928.22266
/Descent -235.83984
/StemV 45.898438
/CapHeight 358.39844
/ItalicAngle 0
/FontBBox [ -1020.50781 -462.89063 1793.457 1232.42188 ]
/FontFile2 16 0 R
>>
endobj
16 0 obj
<<
/Length1 21040
/Filter /FlateDecode
/Length 2340
>>
stream
x��{tT�ǿs�wvC6Yv�MB`׸
$ 
"/����W"jl�l�$H@hA)(񑈺jD�J���Eb�
�R��Q��RE�hW����G{ڞ�������s�<��f~s���c!رD٬��Y7l|q/ �0��&Pgk�&�2c�W4xP�:�A@�Pݢ��cVT���E��:Xap@¢ūB�l1��������\4��UVV�q��yΩ�iX��(^�N���k��^��
$�Rή	���{ʲ�g<K5����
l�������ױ���u�*�&Z?`
���8�� `ke1F�	0�����$#q0A��}5�� k�J���C�9��h�ױ���C,���p�Dt�L�Ѻgwo���{�Ό�^��;_N۸�;}'}�!q��7#/�����/.���y�f��zL�h�d���O��+�`�,d�i���١�A�zv{v[��-ڬ5��2��ý��]V�4idx�oz�#w�|��%^��T=���;Wy:{{g�7ʒ9����ӗv�u�g̘=��qjj���S�
�3��w�h�����gL-��E'퐾�^��)��4;��&4;*&��9�T�ɭ �8+7����E�\m������p<~���~N���uzC&����/������G�,�!P
����r�Vor�ךf�Z��)�)�Ҙ>4}����3.Ǜ�M��V�c�s��YIbl�I99�)o�ļ�מ�Qp��7���˩'r�����ƙW7^uI�9��
�Q�b���Fo�r���)c��^������Q(<SHƘ3��)�8S���ͯ�%��>ufX�P�
T#�yX�"����
,C=�P�%� ��F�Q�Z\�1��FMA-�
�P�E�D<�r�E�QȆ�
�

�G��
� L��#�a1Ã�_Ū��*P[�
T �L�����j�b�5���(��*����}9*c�/�=�A ��U����r,�bT�Q�b}�b,:х.<�vl�Љ�������rtb��?��
'p��]l7!
��.�I�b��&1^��x�ń9��a�5;�w�n��f�Yf֋l�+��mr��g^�t�è�c|��|�,0�8�n�����W�-؊Ft�-j��h4���n��
��B��,�kу;hӰY��)t�$ֲ�X
0����Vt�m�7!{D<�1[���0vM�_��<��hD1�Z:-nk�8۱mb�8n�[p��q)_��4�~sZN���"{D[t�%$V�e1�э+�2юw�2�B4�hF��a̕��q�p�Łn1Q��� ڛ�nk�9���M�P˱�sԈ�����h<��%G�D6�G�Zč�It��2�G}�s�0�i����\1��}�,���y��O?V�����a�'|��9O~��~��x���=�w'���|G�wY<v�H�hs�<Zķ�)ߎ�<�����,���߄����.�����᫊����&��P�4���<��@y@�|Y�%�������r�b�`�"�/(>��)��g��Oq��ӊO)�\�I�'�����ǜܽ�'w+v��#;w�,���p�s�>��4��;s�G}ܡ��0Q��b��Ê�c;�����%������y��W���6���U�{��,�k���Ҝ'��y����fŻ��
rS�w�9�]�����C��p��]1��ۚ��ma�z�]�:��ع1›[�ț[[Je���1[n�ɖR��7�x��
�g���d�z�l���lr����x�z��6���r�������k�r��5N^��Fq�bn�UMM�*Ŧ&~/���$���wW)�������rņ�#\���k�(.��
�jg��.b�be9�eH�B1�X��P10�e^��R�o+.P,�/K"��K��K�8O��$yI>��X$��?�9�����8��Y�3/vș�;x���~r�b�t�,��驉r���y��aN
�@q��S"��ü�U�����]�|7'O�+'�8ib����ۗ9Aq��y9ny^�9�2��qcmr��cm3�ى�m�Y��m5�&G%r����>2�AfdqĹ>9"�s���>wq�P��ǡ>��l2�/}6����xv_z�Cz]�9$����rp����̗�FxV>8����A�$�)���!�0Iѭ�O��̗.E���|:��7H�bbB�LTL��L�b��}���S��i	�i*�&��K*�!
?��P�"��F1�
���OIp�V��j�Z�V��j�Z�V��j��w�;�߳F��h4�F��h4�F��h4�F��h4�F��h4�F��h���)��B���
endstream
endobj
17 0 obj
<<
/Filter /FlateDecode
/Length 232
>>
stream
x�]��j�0��~
�C���&��r���
[I
�l琷�B;H ��৏��ړ��?R�3��\�%��"8yb���y�j��������%������'����Ņ
���'������G���7�Hk[p82�^M|33��S������k�M�Ͽ468\���MȤB� ���Z����w�0ڻIL��Sׂl�幪�}��PvM	)�*HA����b��U�V�o�
endstream
endobj
18 0 obj
<<
/Filter /FlateDecode
/Length 1469
>>
stream
x��Y�n�6}�W�<�/C (���yn`��6)
�@���!)�����:ʓm�Β�3g.q�%�?��
�3������$@ʐ���AR��?N����GW�}��|���fE\N�}�k�<�>}��
)B��}��m��߉s��'*O���)�����dBf�,�8'�1��
��q��A�Pjp�� �J��=��	
`N��d��	F@N�M���\�+�$E,�R"'� �BY�G@	�"P�X��	"�e��Dz���h��@V̳0�NX�n8t�Sȅ�*x���@�j�<�)&��ϔD$��”Pd�fJ
�S-dR��
&����1i��G��T�}�Sw0i:ue��^O�\�C4��&�Q�0��&��d��e8yE@�F&P�PSޤW�i���0�@NR�lԙ4��23l�d�-�0?"$����o&�xrݿ&��4Y�YT��EJ�=L=���{�=JGez@w�{����IX���Փ�����	�K&~ZR~��w��~��ԑ�Vbx��1��1�u쵒�V��J�Z�~m%jF@G��BE�C%���U�ן>�����nzs�Ew�y����2���{��"�l�~sw�L�~�ěn|@�T�KD�ZD�Cjϡ�a{> z_���/c}���3��&#�HMen�~\;�ks-nb!��O��Qn�O���Y�ds�_�,sɃ�!���}jf�b���2��������ڳ�q��B57���cf���63x_;��3K�������Y�ciZ,�d%`� ����L�+R\���H!@������S]Ll�Rr��'�f������Dz�b�/���LI�Ԋ�0ߧ�'�����(�vڬ���u�2�+�+��ES��Т��+�V�
?��e���Š�]�PdQ"��Yy	kK���[E|c -58�/�ڝ�#�<��B��;�ҳJ#D�Z�v�Y$�H���ۺ����Ѯ.��Pyr��¾]�m�7����'��*���a�_;��B���
�j�;�1hL=���6�`��O,��G�k�or��B�G��?���v�y���P��n��C���&n�@]�$@�d/\Wx�a�s���׭QƖ��;i_�=�Ӿ���"S>���7�=�[���Ǫ!A"�3�+��0��Բ�G_�d���]╽���	��4�%�j�pZ�Z��uMr�7ӵMr��w��O}[�p/m�Cλf����I.
q���5�|[_��s��&���V������5a����zaoy��l�?C?�̶f�&+ús�����E��^A$�5tW�5�kr�L6������rVt棔=-N����?:��sqt<})��OG7Y��}����]�TrO��vu�M+�㳲��뇉Kw��ysZ:ظ����(`�4���4,��9ٴ��*
�)��S����]��>{`x�
2�̇�z��@�:���
���
endstream
endobj
19 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 20 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
20 0 obj
<<
/Filter /FlateDecode
/Length 1235
>>
stream
x��Y�n7}����!)R (P��~n�@?�mv������7C;���63ˑx=<���6���_�0�`�_��b�K�[
����u!�~�<�r�����ɚo�-i�5ѫ����u�c��+`$^��(
!Ik�4�.��B�ռ�ߩw
�ռT�D����p���!	��"�cV�9=h��y��lTI�@ D�X��ѻ,��Xt��C�B����
��I�R4����ME���K�9�NE
�����l,:�@d,[�
c/j,�\�&R�0i�Y�—��YP*��L΃����'���C���9��&@�t��)���QV���`Q�2�8�<��)`�pP�!X:, %�,��E8�"m�‚���oM�$�t,b���M�9�Z����� ����&�9��dR�r2k�XD����$c�0�"�,��V�$UM�[}��A��
��R`�����o��&:X�3�{\w�{��z����wU�X�!��>=�����j�{��
g</�3�\��;
5qo���h���>���>���ޛ��wb����Z���$�a^��ɔ��|���ӣrf�u�2*��|�ٽ.�ю����e����z�!�1��(
Qb�!\?D�z�]�����Ǻo�Ho�f4���z}]���!��c�(9�-2M
�����ZN듩O��v�� S�_��`�]]�R��XK�j��	�u�P�؉����(RA�`�x�Z�{ԖO�l��ɚ������y(�T���|ʺ��	�gκ�[Fu8W�_}������,��d�Sb-4������G�s�[�jo���Nd��M{����#s��G������`��SY��נn�v��l4<���z�$̜��a]��؉\����֒�5{ְ5�M��x�x���涞E'����v��,�M����\��n�?`��ٲ�캞\�Y�p6X;��Gg�:�K;Aۼ3�[b�=c�ִ�La0ߚ�볁k�)~xn����D�?'����_�خ���ֱ߬G������;�^�"��\'{}���uX������ː�k�\�ـwYv�٦~�;�ʜ��
#�5�5�q~c�&��T{�����uo �h��g�˹u8���y��@+zȅu��/�������s,�=������m'��;��v��s��ϛ�`'�{r�`��ؐ�Y������ބ3&�����)��rQ�/8�M��>'�4�չ���/��
��`
endstream
endobj
21 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 22 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
22 0 obj
<<
/Filter /FlateDecode
/Length 1139
>>
stream
x��X�n7}߯�x2Wrl��s
��IQ���?P��]Ҋ��a��m,D�rșsf)K�?
�+�tepOӗI���yĢ �><M����0�~���K���T��Z����?�Oӯӗ�p
F��ԃ�xv-sO�#x�A��n��ڮ܉��c�hN�!���9A�ɽ!���9�$�F5� �K6�V�DAPs��&1� 
9y�6�1Uw�lNR�	��!�du'ɐ\9E��Ƥ����!g�u/e�)d�<�� <��,&&����81E
�9���j�`J"���Ô(2��3%S�1K&'�D�0��b[`��#Ĉ<���\X�`�.��:�e�����؋�87S��ǩ;3�3p,�e�b���C<L��y���^���2,�s�L��
̆[�
���o1(�@E��R�ya�Xj`��T����b*@,��m�S/��ܫoݣ��L/�v��5��%#k;u�z�uX��|����Sk��~�ӟUGN�ؕg,+�U1���-D����iٛ��iٛ���Z6h��$�~
����g��a}��>̃�z7��ݝ�a�i���H�ja����#���/a��t�?�)	��(��&DuD���Q����n~o;D�i6o����k���wfm��>����$��e���v�;� 2�
�n�`.La���#�	#�u�_�݆�/��\e�[02�e�h��e��t�����_�s�pM����;�F���Ŷ���* ��@zhI@�p9���aF� r,�
1���f���˰�ҳ�r;�"�r�Hn/˕�)��	z55��ϖ4�\ClH/_T��r�-mc-��q5�&9u�}?pᕗ����G<UH��Y��}3ۅ�9!�#��e*��μ������|ZM˻���9�{�>��!�������Q"G������e�m`�ȭ�p�
&�@DN�n< 5��X�����~?c�d��ٙb���L�����SUC��`nY�_^6���PnU����
�.W�n���U���?nP�(��h;ձ�?�c���Oszn�����xۍmc���\�J:����ڿ9쑹(�/kK'��9�m���`iI�ׁ�v�Kv\W�����T�+���W�<��]�u�/<��
endstream
endobj
23 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 24 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
24 0 obj
<<
/Filter /FlateDecode
/Length 1224
>>
stream
x��X�n7}߯���+9��b����~�ۤ(�I�(x�%���ʒ
?8�B��p�̙!O��܍���7s��ӏ�=��%��X<��y�8���޹���������lD]��~�9}�~�~L�0�(�D�%���w��D)x��Иѓ���A4M�����b�{E�R�!D��F� �QJ��#4�gw?1�7N*V�
�1��Cͫd,x�h���^"���|RC��x
�H�9j�΂��1�!@
�̓(f�|Jꆖ�1�cb�RE�@☬�c���O���
}�+%6�Ό�[F8FX(!<H��r�)VR�	",+���&av�x'�[[/U9N<�(֔������=4t�����3����SƲu�BcaOвj	d4z`u=S4V�r�J�س��kc0��S댙W�.h�#�b=s�Q��ʹ�#/��"�
e"f�����U�
��]�c(]�=��=��=#
K�u�zC�.�{P��χZ-a���4���*c��w���Bύ9�	���v��c�}�w5�ƙ��#�/�Rvm$��PV|�s����~������MX��ʸ�����/�����=����M{U1�j��b�����+������T��Xw�Cp
@s@T���3.T/k6�=�ᗺ-5\��@���[��q؋
d����W��e�X����@�ZZ>����|�s����6�T�����/���~מ��s��v��//G���p4�_(YA9�<������J�Fr��{vu)�5r��Oȵ䕟� 9im�l[��H�Lt��R)��n�WJypw)��}+���e�Z��H=�~�����_�pA+9~'�W�����3�z�{��p8��o��f&f\��+kO��W�R�����H����}�r�2�Um��z9��W=ߺ�|�Z��������fE�aݽ�c���oأ�]�z�x|J�zY��=ч������p-�D^��vX��w]�E:}}��梎MoFV�����i9I��|��y8����v�Cl���]��s���o���_
,.����df����ۡ��3܎8j,sV�zz�^-�����?���i�U��YY�mV����p��R����`�fex�Fx���CV�\�J/�Ǧ���*�e����Y�x�8��F���5�FhՅ��RZ�+����e��Z��A�k}�}K��W�v��
g���r��
endstream
endobj
25 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 26 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
26 0 obj
<<
/Filter /FlateDecode
/Length 1316
>>
stream
x��X�jG��O1/E׹@(؎��
�>�ۤ������mg���^_��ݣ��H��OK*�:t`��!Fw{�|_��|R�X$����B.��r��Ïo��kq��[�*��R0�������}9T�H�F'�1E�����]8y������*�@����k2M�H	A{�)��!�*�
Br��I�*����"�%�13�;A
L�W���9A�!�*� jUC�d��ȅ���b	V�
a'䁼�j�E�:(AJ���!��HS�Д�p,�h"s�����*�[���Q��e�
5m�a
"�b
�6.0��
��e������t4$���7�3���
b�	��A4)!xָ�|��I�4�Ȧ�e���F!/�[�qb0�4���D��Y���C���Y(�
&�<hh^u�8����퀓	x<E'X���C��
Q0G�=-;���袌IO�!�[F���#/�]Fo,?Y?�c�sT����V�Fq� ���
�Z�s�V������.�y��>�!⣜��4���g�{g�w�{g�w����o�RG�@ȵ�V��1�����˵��#�o��W�Ȼ�����\aΤ��~���������g��y@�X�����%y�d|t��WJ�3�z��z�������l�h�����c��~�ޟ�5����bzC�&uz�h\/��]TC��.�;������Ds���
Q��J���e՗�/5r��ok�S�ߏ0�f4���!���ځ��Ee�Ϩ��d~�w���ڒU[����o߮YGj��e��	P}��͟�S�n/,ɟ����'J����YM����-��.�o�7����+�)�nR�-�j=
�[��Nq���8o�t�U]ΑM�u�X��EG�T�"_�������Z<�՞nƊ�i���6����w٫��C;��}�3�C��0���F
��&��&�*��t{s��$�x�/Z��H’��N+�/��5<��p��gG*li9��d��#=V�n@���{(D�N���o�1�k�X�!L�V�8Z�a�z�gq9�س�����Փ��s�V�Ǫ/�z�?[�F�z��J��x�,@�.�eM��e�ѳ<lj��<������J=e�ʰ�GgN<k�5>�&�y��m���8m���X����
�#\D{�Koz&�����f����=֯7(�tTOo:�
u���G�>!�md�I�lc[��i�8��=��:IO�W+Crl�;�
�U��L�Nj�P[��d�L��jK.�?���r��X�w2�Z?m��؟�*T�ɏ%�s{����t{w������
endstream
endobj
27 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 28 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
28 0 obj
<<
/Filter /FlateDecode
/Length 1099
>>
stream
x��X�n7}߯�x29��k����~�ۤ(�I�(xY�R����y����C9g��,!`I�ϡCw�W�f��i�>	kYRG,$�χ��\��|������ý���N�*xu)�����e�}�>�n�H
�7'�,��k�p�&N
,�#f����\QLZ�yl�O��8��!�hV�@������
h�&A��������
ؒ�-UP����AR#��
�b�ZO2��PX}2���� %�Y&���ajX��8a+�����IS�����f�"(�4�	D$��(0��3E��Q&#�Nb�d<6�?&�g&3`�v�&K`B�飄��Q�+x��l��Y;�S�&fO���ɠBh~6�2��k�.5�Y�Bq���`�CH2�@S��s�90(�Li�s=D�<�$�
$b�霾GHZ��A���M
�
��s����nڵ8��u;�CE����bX��9�ȡ�z�z)�A>��Q>>����$�������_�onWd�ѹ����]�0���.���޻�{��5���MZ�%��䦥֋�vD,+>߻:�q��>�yG���LTo��J�L��O�GD�!�����T��Q�WL���<ڼo��H��=8��w���_�OY�Ûl�����n�g�N���|J�[J�h9z��j�P�{��E��E��,z�:UAs����rED�Bڸ�%O�a_k���lp��p�M	����hȝ�_B�ض$2l�����gY�9�����M����9���PѾ�OË���$_c���ɳ_���a���i���_{Z��Yͱ� m�,��&��E3��n)���R��ۦ�؝,*ø�RJ�i ����)_4mJ�o7�hs�4ջ�R��ʝ�jQ��]�b�2mu���O�|�E{�e�����QQ�o��cïE�#J�������J<܊�[�}�O����-��lvo�
����bA>`�Dt�?��٢�q9Q��g%9�~��g��)��_��gʙF������^tk�ߺ��J[1]}/k�֬_� �����5k֯`�\�y
��o[���{�a.q��m��>��V�"���^�

endstream
endobj
29 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 30 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
30 0 obj
<<
/Filter /FlateDecode
/Length 1150
>>
stream
x��X�n#7}���,�Q�E�؍�܅�~��ݢH
����B��NO��%1O(�<<�(i��ʟC���&ϐ�;<L�&
b-S������0�˟�w�>|�:}����)k�΢��N_�ߦoө
F
}r�^!Y�y��-@��!���E�	�}x�U䁼8�!Ĕ�0
�96V�\�D`�aDHb�X!&u�h1T�
� �dE�h��'0M$U���N�A$j��8�
@!`E�	R(��̇�L����=!
g�8��"u��I��؅�SPj�7m�A���)�H<��(0���b��c�L��G:a�)y��4�R��G��R����”��q
k!�t��:ZMd�&Y
�~�F�!�\�ad	��
p��AW0
�1�D�z��hm�˜"c���fL
A11�kL�0&oJE{N�1ԉsr�(����a��e�O��a/��~/�H����~�����e=�\�U70�,Б�e)9Z�����^q��*M�|��bz���c{�d�콓�w����ƎQ��ڿYkok�fe��2����m��ǝw���D��H��B���a���
���FDUD�V��2���㿸�����9�Q�uS�y����7���D��7����{��#AD=���E��^��q{������l�X�6/�A����M��yy��
�)]�x���{
���2�q���\D��̋���5%BL�lG�����
�>��_8˨6ϠZ�(��!Z����7By��˼���f5��^v9%y�-���$�~m�_ig
�$|U�9�5Q�$�x��]5�n.��ZSX�J�U�^5�nN�P�h
�k��6�e]�װ���tMRss����՞�y��a�^]W���,��-��\�-.���cE��'�
�~*G���"�v�x��#�'�\���G����r{UO��5�"/��Z,�n�o��kE����q���3_���-�]����Y�E%`D!q���O
F�v۠����&�]���쮺�t�9�#2ij7El�m���E~�Kĥx�Pt���M�k�w�4��#����9��uDO'��G|KD����[	�!�/(�;�(^�R�R��$N�%J�wU���ͦ��~\(3�����Bv�
endstream
endobj
31 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 32 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
32 0 obj
<<
/Filter /FlateDecode
/Length 1340
>>
stream
x��X�n7}�����E$% (`ob?70�p��] ���.3�:�fܵ�lc13Q�9$��,������"CJ��~��k��X"�����B�������������.�ˢ��~��|Y~_�/'`$�)F��S,c��,�
�k0���~��㈱��uc�^�J��g3O�c���U��1A�� B�������D#�٭�Pr4@���1Av��	�&�jv��D\�J�ʔd@f�br�uyʐs���;� ,��nL@,A8�l&
���J�d�[�L@����L�����G��
dL3&O��t eJ��
'L)B����cJf�3�L)
GM�IaJ��q)#�t��f<���߭k��-��(:�,�2FJ�<�)"#UpL-���U��id�L'>�L!E�lv�,���l�[I
��#g0F��kތ<���_��Dkԧ�e���x��j��Qq�|�6��T+{+���
e4�zk���h��ŭ+g�����5���q�|���p��H���)�b�������`o
��`o
��
6+Eo
J�dm��uf��a��:���v�7�����͗�ډ�B�@���~��1&ĘQ�����패������{y�K�r���>1"Ƌfë>�M�&#"	"Q�FD*>D��[��{�ts
�{GPV�Ӟ��09���Q������1u'��8�>������O�Հ�Z���h��R{��IeI������M� %k�����0yQ�t5��(�D	t-���qi���"�g��_V�j�Z�;)L�[�Y��t�k|�� GD> JoG)EF�v_��f<;�1}JZ���**���.1�YY�Of]�(c�A��y̫0�Rϫ��*��M�(�UI���ȩW�u�#JCC.˹*`��3|؂��۫u-����g��j�ٴF��:�����Gci{/N�e����Q�ċ����vT���JҞt%</]��kU9u���_�M�9�h�G:��U:F#W�O��y�W�3�E�-���20
Me�mj���Ԣ��Q�ꔵ�o��2�	M����g��K~�����ͿD�i��W�+Rݧ��_�,2M��V�˓cu�t�l����Æ�j�"��udJ�+���wLW�bn���U?�q��O�SQ�<{�V�/
jLW]T7F��hc��Y�����'����;�hk��z�<�/l��D����_�]ۗ��t쎃�*���ҋr<��m��u��Z�dֲ궟H��3u���~\��+�:	��W��X�i/]��=n��!񦏋��Ն�s-��>��鼣��׵:sV�<���{�e��=�q��>=�����
�r�
endstream
endobj
33 0 obj
<<
/Type /Page
/Resources <<
/ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
/ExtGState <<
/G3 5 0 R
>>
/Font <<
/F4 6 0 R
>>
>>
/MediaBox [ 0 0 595.91998 842.88 ]
/Contents 34 0 R
/Tabs /S
/Parent 1 0 R
>>
endobj
34 0 obj
<<
/Filter /FlateDecode
/Length 1266
>>
stream
x��X�n7}�����E�H�(`�����M��.����B�i��4^�/N��	gD���G���?
�0��"�Yx|^�.�Z_iw,$����B���t�ͷ/��{	_�Yʪ5x��������u9v�H	r� �-�w/�	,k�7ϛ�gt���ۢ�f�`.�=CJ٬		,����*��Q!���E��56���A
�����bL��͛Q�b��
\���
r	�D�����SJ@)a��yq@�1��8�a
7���nA�j���Τ^a얧�)	(���:��A1��S&�|
SV��4GΔ
4��92A�t��E��t�,AJ�3�Lf�Q�� L�`B��#GH����8�,�ƍ8O�X-�!|�6R�FT�"B+�Ԁz�R�I���%���D
F�W@;vR�t$d)� u��!�
�DQV���R�5����֙�M���n3=-�Vc����bPuf�z�=�?��2���@l�ބ�֦5�:z����SU�U�q����i-+,��Ō1X!}���*h��.i��.i���M�Q� k|dm
�eg��a}��>��!}��ǻ(����y�BD���y�	�������r�p“*h!��N#�b4DUD�i��5��U�{��1:"*���緈����/w��l��cj��"�
"ѴV�������)pL���w%����j�&���ˎ�
w�ߒ��&��@ˣ[Ik6/G�b��w�[kc��!��vGp)�)����	"� F%�)�ԽIH�h���C��nG���6��_�.�ט������t��3kc��Б�I�f8��^�^ժqk��*�
��]�23���l��&\kmJ�Ż�͚�4�1_[F;��K���.�˛Sܧ�;7��`�|t&vA���u�\
�D�<��l�:���ۮu�'4��3�����^6w�	����A<��"����L1o�N%rDڙ�>aۙ�pW��>Ql}5%��6׊�`���X_E�	��E
�ܝ��k�&tQ�F��*��S*����(�j�ʒ���K�7���?N'X����G�ƹ��o�+����t0"_�{�-��<!J�Qs$c�m �/���|���G}�C�8��.�Ț~���}<��t�vR�	�k��u՛u�N&j���q~�d�V>^���YQ�];�
�pw�ΏDO쯂b��d!
��F�~���1����Po`���7�%��&w{����߭I�'jgx#u��i�Σ�k�d�����v�6	�	����i�E���.:0
w5�v����q�H2Y�3�_�=��
endstream
endobj
xref
0 35
0000000000 65535 f 
0000000015 00000 n 
0000000138 00000 n 
0000000178 00000 n 
0000000227 00000 n 
0000000449 00000 n 
0000000488 00000 n 
0000000630 00000 n 
0000001555 00000 n 
0000001798 00000 n 
0000026793 00000 n 
0000027188 00000 n 
0000028482 00000 n 
0000028716 00000 n 
0000028863 00000 n 
0000029117 00000 n 
0000029365 00000 n 
0000031794 00000 n 
0000032099 00000 n 
0000033642 00000 n 
0000033865 00000 n 
0000035174 00000 n 
0000035397 00000 n 
0000036610 00000 n 
0000036833 00000 n 
0000038131 00000 n 
0000038354 00000 n 
0000039744 00000 n 
0000039967 00000 n 
0000041140 00000 n 
0000041363 00000 n 
0000042587 00000 n 
0000042810 00000 n 
0000044224 00000 n 
0000044447 00000 n 
trailer
<<
/Size 35
/Root 3 0 R
/Info 2 0 R
>>
startxref
45787
%%EOF

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END
class State(TypedDict):
    query: str
    intent: str
    response: str
def classify(state):
    q = state["query"].lower()

    if "admission" in q:
        state["intent"] = "admission"
    elif "exam" in q:
        state["intent"] = "exam"
    elif "fee" in q or "fees" in q:
        state["intent"] = "fees"
    else:
        state["intent"] = "scholarship"

    return state
def admission(state):
    state["response"] = "Admission starts in July. Apply online with required documents."
    return state

def exam(state):
    state["response"] = "Entrance exam will be held in August."
    return state

def fees(state):
    state["response"] = "B.Tech yearly fee is ₹80,000."
    return state

def scholarship(state):
    state["response"] = "Scholarships are available based on merit and income."
    return state
def route(state):
    return state["intent"]
builder = StateGraph(State)

builder.add_node("Classifier", classify)
builder.add_node("Admission", admission)
builder.add_node("Exam", exam)
builder.add_node("Fees", fees)
builder.add_node("Scholarship", scholarship)

builder.set_entry_point("Classifier")

builder.add_conditional_edges(
    "Classifier",
    route,
    {
        "admission": "Admission",
        "exam": "Exam",
        "fees": "Fees",
        "scholarship": "Scholarship",
    },
)

builder.add_edge("Admission", END)
builder.add_edge("Exam", END)
builder.add_edge("Fees", END)
builder.add_edge("Scholarship", END)

graph = builder.compile()
query = input("Ask your question: ")

result = graph.invoke(
    {
        "query": query,
        "intent": "",
        "response": "",
    }
)

print("\nResponse:", result["response"])

Open full submission →

from langgraph.graph import StateGraph ,START,END
from typing import TypedDict

class State(TypedDict):
    query:str
    intent:str
    answer:str
    

builder = StateGraph(State)

def intent_classifier(state):
    query=state["query"].lower()

    if "admission" in query:
        return{"intent":"admission"}

    if "exam" in query:
        return{"intent":"exam"}
    
    if "fee" in query:
        return{"intent":"fee"}

    if "scholarship" in query:
        return{"intent":"scholarship"}

    return{"intent":"unknow"}


def admission_agent(state):
    return{"answer":"Admission details......"}

def exam_agent(state):
    return{"answer":"exam details......"}

def fee_agent(state):
    return{"answer":"fee details......"}

def scholarship_agent(state):
    return{"answer":"scholarship details......"}

def response_agent(state):
    print(state["answer"])
    return state

def router (state):
    return state["intent"]


builder.add_node("intent" ,intent_classifier)
builder.add_node("admission" ,admission_agent)
builder.add_node("exam" ,exam_agent)
builder.add_node("fee" ,fee_agent)
builder.add_node("scholarship" ,scholarship_agent)
builder.add_node("response" ,response_agent) 


builder.add_edge(START ,"intent")

builder.add_conditional_edges(
    "intent",
    router,
    {
        "admission" : "admission",
        "exam" : "exam",
        "fee" : "fee",
        "scholarship" : "scholarship",
    }
)

builder.add_edge("admission","response")
builder.add_edge("exam","response")
builder.add_edge("fee","response")
builder.add_edge("scholarship","response")
builder.add_edge("response",END)

graph = builder.compile()


intial_state = {"query":"tell me fee off class 5"}

result = graph.invoke(intial_state)

print(result)

Open full submission →

import os
from dotenv import load_dotenv

from typing import TypedDict

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini")

# -----------------------------
# State
# -----------------------------

class AgentState(TypedDict):
    question: str
    intent: str
    answer: str


# -----------------------------
# Intent Classifier
# -----------------------------

def intent_classifier(state: AgentState):

    question = state["question"]

    prompt = f"""
You are an Intent Classifier.

Classify the question into ONLY one category.

Categories:

Admission
Exam
Fees
Scholarship

Question:
{question}

Return only category name.
"""

    response = llm.invoke([HumanMessage(content=prompt)])

    intent = response.content.strip()

    return {"intent": intent}


# -----------------------------
# Admission Agent
# -----------------------------

def admission_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Admission Agent.

Answer admission related questions.

Question:
{question}
"""

    response = llm.invoke(question)

    return {"answer": response.content}


# -----------------------------
# Exam Agent
# -----------------------------

def exam_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Exam Agent.

Answer exam related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Fees Agent
# -----------------------------

def fees_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Fees Agent.

Answer fee related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Scholarship Agent
# -----------------------------

def scholarship_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Scholarship Agent.

Answer scholarship related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Response Agent
# -----------------------------

def response_agent(state: AgentState):

    return {"answer": state["answer"]}


# -----------------------------
# Router
# -----------------------------

def router(state: AgentState):

    intent = state["intent"].lower()

    if "admission" in intent:
        return "Admission Agent"

    elif "exam" in intent:
        return "Exam Agent"

    elif "fees" in intent:
        return "Fees Agent"

    else:
        return "Scholarship Agent"


# -----------------------------
# Graph
# -----------------------------

graph = StateGraph(AgentState)

graph.add_node("Intent Classifier", intent_classifier)

graph.add_node("Admission Agent", admission_agent)
graph.add_node("Exam Agent", exam_agent)
graph.add_node("Fees Agent", fees_agent)
graph.add_node("Scholarship Agent", scholarship_agent)

graph.add_node("Response Agent", response_agent)

graph.set_entry_point("Intent Classifier")

graph.add_conditional_edges(
    "Intent Classifier",
    router,
    {
        "Admission Agent": "Admission Agent",
        "Exam Agent": "Exam Agent",
        "Fees Agent": "Fees Agent",
        "Scholarship Agent": "Scholarship Agent",
    },
)

graph.add_edge("Admission Agent", "Response Agent")
graph.add_edge("Exam Agent", "Response Agent")
graph.add_edge("Fees Agent", "Response Agent")
graph.add_edge("Scholarship Agent", "Response Agent")

graph.add_edge("Response Agent", END)

app = graph.compile()


# -----------------------------
# Run
# -----------------------------

while True:

    q = input("\nAsk Question: ")

    if q.lower() == "exit":
        break

    result = app.invoke(
        {
            "question": q,
            "intent": "",
            "answer": "",
        }
    )

    print("\nAnswer:\n")
    print(result["answer"])

Open full submission →

Project Name: College Inquiry System

GitHub Repository:
https://github.com/ganeshmahto/College_Inquiry_System/tree/main/nodes

Live Demo:
https://collegeinquirysystem-695haaywrwvhjweakguvzm.streamlit.app/

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END


class StudentState(TypedDict):
    query: str
    intent: str
    response: str


def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state


def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. "
        "Students should submit the application form with all required documents."
    )
    return state


def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state


def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state


def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state


def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state


def route(state: StudentState):
    return state["intent"]


workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")

workflow.add_edge("Response Agent", END)

app = workflow.compile()


print("===== College Student Assistant =====")
query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

# my project link (Rajnandani Kumari )
"https://github.com/Nandani080/my_project/tree/main"

Open full submission →

//Aman Kumar
//Github Link=https://github.com/iamamanksah/College_Assistant

Open full submission →

from typing import TypedDict, List
from langgraph.graph import StateGraph, START, END
class UniversityState(TypedDict):
    query: str
    intent: str
    department: str
    response: str
    history: List[str]
DEPARTMENTS = {
    "cse": "Computer Science Engineering",
    "computer": "Computer Science Engineering",
    "cs": "Computer Science Engineering",

    "ece": "Electronics and Communication Engineering",
    "electronics": "Electronics and Communication Engineering",

    "eee": "Electrical Engineering",
    "electrical": "Electrical Engineering",

    "me": "Mechanical Engineering",
    "mech": "Mechanical Engineering",
    "mechanical": "Mechanical Engineering",

    "civil": "Civil Engineering",
}
def classifier(state: UniversityState):

    text = state["query"].lower()

    if any(word in text for word in [
        "admission",
        "admit",
        "apply",
        "eligibility",
        "cutoff"
    ]):
        intent = "admission"

    elif any(word in text for word in [
        "fee",
        "fees",
        "payment",
        "tuition"
    ]):
        intent = "fees"

    elif any(word in text for word in [
        "exam",
        "semester",
        "result",
        "admit card",
        "routine"
    ]):
        intent = "exam"

    elif any(word in text for word in [
        "scholarship",
        "e-kalyan",
        "financial"
    ]):
        intent = "scholarship"

    elif any(word in text for word in [
        "hostel",
        "mess",
        "room"
    ]):
        intent = "hostel"

    elif any(word in text for word in [
        "placement",
        "package",
        "job",
        "salary",
        "recruiter"
    ]):
        intent = "placement"

    else:
        intent = "unknown"

    return {"intent": intent}
def department_detector(state: UniversityState):

    text = state["query"].lower()

    department = "General"

    for key, value in DEPARTMENTS.items():

        if key in text:
            department = value
            break

    return {"department": department}
def admission_agent(state: UniversityState):

    dept = state["department"]

    response = f"""
🎓 Admission Agent

Department : {dept}

Admission Process

1. Fill Online Application Form

2. Upload Documents
   • 10th Marksheet
   • 12th Marksheet
   • Aadhaar Card
   • Passport Size Photo

3. Pay Registration Fee

4. Submit Application

5. Download Acknowledgement

6. Wait for Merit List

7. Document Verification

8. Final Admission Confirmation
"""

    return {"response": response}
def fees_agent(state: UniversityState):

    dept = state["department"]

    response = f"""
💰 Fees Agent

Department : {dept}

Approx Fees

Tuition Fee      : ₹73,000

Hostel Fee       : ₹20,000

Registration Fee : ₹5,000

Library Fee      : ₹2,000

Exam Fee         : ₹2,500
"""

    return {"response": response}
def exam_agent(state: UniversityState):

    response = """
📝 Exam Agent

Semester Exam

Mid Semester :
September

End Semester :
December

Admit Card :
Available before exam

Result :
Usually published within 30 days.
"""

    return {"response": response}
def scholarship_agent(state: UniversityState):

    response = """
🎓 Scholarship Agent

Available Scholarships

• Merit Scholarship

• SC Scholarship

• ST Scholarship

• OBC Scholarship

• E-Kalyan Scholarship

• NSP Scholarship
"""

    return {"response": response}
def hostel_agent(state: UniversityState):

    response = """
🏠 Hostel Agent

Separate Boys Hostel

Separate Girls Hostel

Mess Available

24×7 Electricity

WiFi Available

RO Drinking Water

Security Available
"""

    return {"response": response}
def placement_agent(state: UniversityState):

    dept = state["department"]

    response = f"""
💼 Placement Agent

Department :
{dept}

Average Package :
₹4 LPA

Highest Package :
₹12 LPA

Top Recruiters

• TCS

• Infosys

• Wipro

• Cognizant

• Capgemini
"""

    return {"response": response}
def unknown_agent(state: UniversityState):

    return {
        "response":
"""
❌ Sorry

I can answer only about

• Admission

• Fees

• Exam

• Scholarship

• Hostel

• Placement
"""
    }
def formatter(state: UniversityState):

    history = state.get("history", [])

    history.append(f"User : {state['query']}")
    history.append(f"Bot  : {state['response']}")

    return {
        "response": state["response"],
        "history": history
    }
def router(state: UniversityState):

    return state["intent"]
workflow = StateGraph(UniversityState)

workflow.add_node("Classifier", classifier)
workflow.add_node("Department", department_detector)

workflow.add_node("Admission", admission_agent)
workflow.add_node("Fees", fees_agent)
workflow.add_node("Exam", exam_agent)
workflow.add_node("Scholarship", scholarship_agent)
workflow.add_node("Hostel", hostel_agent)
workflow.add_node("Placement", placement_agent)
workflow.add_node("Unknown", unknown_agent)

workflow.add_node("Formatter", formatter)

workflow.add_edge(START, "Classifier")

workflow.add_edge("Classifier", "Department")


workflow.add_conditional_edges(

    "Department",

    router,

    {

        "admission": "Admission",

        "fees": "Fees",

        "exam": "Exam",

        "scholarship": "Scholarship",

        "hostel": "Hostel",

        "placement": "Placement",

        "unknown": "Unknown"

    }

)


workflow.add_edge("Admission", "Formatter")
workflow.add_edge("Fees", "Formatter")
workflow.add_edge("Exam", "Formatter")
workflow.add_edge("Scholarship", "Formatter")
workflow.add_edge("Hostel", "Formatter")
workflow.add_edge("Placement", "Formatter")
workflow.add_edge("Unknown", "Formatter")

workflow.add_edge("Formatter", END)

app = workflow.compile()
def chat():

    print("=" * 60)
    print("🎓 UNIVERSITY AI MULTI-AGENT SYSTEM")
    print("=" * 60)

    print("\nAvailable Topics")
    print("------------------------------")
    print("Admission")
    print("Fees")
    print("Exam")
    print("Scholarship")
    print("Hostel")
    print("Placement")
    print("------------------------------")

    print("\nDepartments")
    print("------------------------------")
    print("CSE")
    print("ECE")
    print("EEE")
    print("Mechanical")
    print("Civil")
    print("------------------------------")

    print("\nType 'bye' to exit.\n")

    history = []

    while True:

        query = input("You : ").strip()

        if query.lower() in ["bye", "exit", "quit"]:

            print("\nBot : 👋 Thank you. Have a nice day!")
            break

        state = {

            "query": query,

            "intent": "",

            "department": "",

            "response": "",

            "history": history

        }

        result = app.invoke(state)

        history = result["history"]

        print("\nBot :")
        print(result["response"])
        print()
if __name__ == "__main__":
    chat()

Open full submission →

import time
import random
import sys
from typing import TypedDict
from langgraph.graph import StateGraph, END


class AgentState(TypedDict):
    """This dictionary is passed along the graph. Each node can read or update it."""
    user_input: str
    intent: str
    agent_response: str
    final_output: str

 
class AdmissionAgent:
    def get_info(self) -> str:
        return (
            " [ADMISSION DESK]\n"
            "University Admissions Portal.\n\n"
            "Here is the UGC-approved admission process for the 2026 academic session:\n"
            "  1. Application: Register via the official portal (requires Aadhar integration).\n"
            "  2. Eligibility: Valid JEE Main or CUET UG score is mandatory for B.Tech.\n"
            "  3. Documentation: Upload 10th & 12th Marksheets, Transfer Certificate (TC),\n"
            "     and Category Certificate (if applicable).\n"
            "  4. Fee Payment: Pay the ₹2,000 non-refundable counseling fee via UPI or NetBanking.\n\n"
            " Pro-Tip: Seat allocation is based on centralized counseling rounds (JoSAA/CSAB). "
            "Keep an eye on the portal for cutoff dates!"
        )

class ExamAgent:
    def get_info(self) -> str:
        return (
            " [EXAMINATION CELL]\n"
            "Important Updates for the Current Odd Semester (Winter):\n\n"
            "  • End-Semester Exams: Commencing strictly from 10th December.\n"
            "  • Hall Tickets: Will be available on the college portal 5 days prior.\n"
            "  • Dues Clearance: Ensure all library and hostel dues are cleared to download your Admit Card.\n\n"
            " Note: A minimum of 75% attendance is strictly required to appear for examinations as per university norms."
        )

class FeesAgent:
    def get_info(self) -> str:
        return (
            " [ACCOUNTS & BILLING]\n"
            "Fee Structure for First-Year B.Tech (Per Semester):\n\n"
            "  • Tuition Fee         : ₹65,000\n"
            "  • Development Fund    : ₹12,000\n"
            "  • Hostel & Mess (Avg) : ₹35,000\n"
            "  • Caution Money       : ₹5,000 (Refundable)\n"
            "  ----------------------------------\n"
            "  Total Estimated       : ₹1,17,000\n\n"
        )

class ScholarshipAgent:
    def get_info(self) -> str:
        return (
            " [SCHOLARSHIP & WELFARE]\n"
            "We believe financial constraints should not hinder education. Available schemes:\n\n"
            "  1. Merit-cum-Means (MCM): 50% tuition waiver for students with family income < ₹5 LPA and CGPA > 8.0.\n"
            "  2. State/Central Schemes: Apply directly via the National Scholarship Portal (NSP).\n"
            "  3. Jharkhand eKalyan: Post-matric scholarship for eligible SC/ST/BC students domiciled in Jharkhand.\n"
            "  4. PMSSS: Special scheme for students from J&K and Ladakh.\n"
            "  5. Category Waivers: As per Govt. of India reservation guidelines for SC/ST/OBC (NCL).\n\n"
            "Visit the Dean of Student Welfare (DSW) office for manual form verifications."
        )

class SemanticRouter:
    def __init__(self):
        self.intent_map = {
            "admission": ["admission", "apply", "join", "enroll", "cutoff", "jee", "cuet", "process"],
            "exam": ["exam", "test", "admit card", "hall ticket", "date sheet", "marks", "result", "semester"],
            "fees": ["fee", "cost", "money", "pay", "tuition", "hostel fee", "loan", "dues"],
            "scholarship": ["scholarship", "waiver", "concession", "financial aid", "nsp", "mcm"],
            "help": ["help", "options", "menu", "what can you do"],
            "exit": ["bye", "exit", "quit", "leave", "close"]
        }

    def detect_intent(self, text: str) -> str:
        text = text.lower().strip()
        for intent, keywords in self.intent_map.items():
            if any(keyword in text for keyword in keywords):
                return intent
        return "unknown"


def node_intent_classifier(state: AgentState):
    """Classifies the user input and updates the state."""
    router = SemanticRouter()
    intent = router.detect_intent(state["user_input"])
    return {"intent": intent}

def node_admission_agent(state: AgentState):
    return {"agent_response": AdmissionAgent().get_info()}

def node_exam_agent(state: AgentState):
    return {"agent_response": ExamAgent().get_info()}

def node_fees_agent(state: AgentState):
    return {"agent_response": FeesAgent().get_info()}

def node_scholarship_agent(state: AgentState):
    return {"agent_response": ScholarshipAgent().get_info()}

def node_response_agent(state: AgentState):
    """Formats the final response based on what was gathered or if it was a system command."""
    intent = state.get("intent")
    
    if intent == "exit":
        messages = [
            "Session terminated. Best of luck with your academic journey!",
            "Goodbye! Feel free to return if you have more questions. ",
            "Logging off."
        ]
        final_text = random.choice(messages)
    elif intent == "help":
        final_text = (
            " [SYSTEM HELPER]\n"
            "I am the AI Assistant for the University.\n"
            "Try asking me things like:\n"
            "  • How do I apply for admission?\n"
            "  • When are the semester exams?\n"
            "  • What is the B.Tech fee structure?\n"
            "  • Are there any scholarships available?\n\n"
            "Type 'exit' to close the session."
        )
    elif intent == "unknown":
        final_text = (
            " [SYSTEM] I couldn't quite understand that query.\n"
            "Currently, I am programmed to assist with Admissions, Exams, Fees, and Scholarships.\n"
            "Please try rephrasing or type 'help' to see your options."
        )
    else:
        
        final_text = state.get("agent_response", "Error generating response.")

    return {"final_output": final_text}

def route_by_intent(state: AgentState) -> str:
    """Reads the intent from the state and determines the next node."""
    intent = state["intent"]
    valid_agents = ["admission", "exam", "fees", "scholarship"]
    
    if intent in valid_agents:
        return f"{intent}_agent" 
    else:
        return "response_agent" 


workflow = StateGraph(AgentState)

workflow.add_node("intent_classifier", node_intent_classifier)
workflow.add_node("admission_agent", node_admission_agent)
workflow.add_node("exam_agent", node_exam_agent)
workflow.add_node("fees_agent", node_fees_agent)
workflow.add_node("scholarship_agent", node_scholarship_agent)
workflow.add_node("response_agent", node_response_agent)

workflow.set_entry_point("intent_classifier")

workflow.add_conditional_edges(
    "intent_classifier",
    route_by_intent,
    {
        "admission_agent": "admission_agent",
        "exam_agent": "exam_agent",
        "fees_agent": "fees_agent",
        "scholarship_agent": "scholarship_agent",
        "response_agent": "response_agent" 
    }
)

workflow.add_edge("admission_agent", "response_agent")
workflow.add_edge("exam_agent", "response_agent")
workflow.add_edge("fees_agent", "response_agent")
workflow.add_edge("scholarship_agent", "response_agent")
workflow.add_edge("response_agent", END)

app = workflow.compile()

def print_delayed(text: str, delay: float = 0.015):
    """Creates a professional typing effect in the terminal."""
    for char in text:
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(delay)
    print("\n")

def main():
    print("=" * 60)
    print("  LANGGRAPH BASED UNIVERSITY AI SYSTEM")
    print("=" * 60)
    
    user_name = input("\n Enter your name to initiate session: ").strip().title()
    if not user_name:
        user_name = "Student"

    welcome_msg = (
        f"\nWelcome, {user_name}! I am the centralized AI Assistant.\n"
        "How can I help you today? (Type 'help' for options)"
    )
    print_delayed(welcome_msg)

    while True:
        user_input = input(f"\n{user_name} > ")
        if not user_input.strip():
            continue

        initial_state = {"user_input": user_input, "intent": "", "agent_response": "", "final_output": ""}
        result_state = app.invoke(initial_state)

        time.sleep(0.3)
        print("-" * 60)
        
        print_delayed(result_state["final_output"])
        print("-" * 60)

        if result_state["intent"] == "exit":
            break

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n Exiting system...")
        sys.exit(0)

Open full submission →

# Jayesh Nag : https://github.com/sevenofatlas/college-assistant-langgraph

Open full submission →

# Manish Murmu

https://github.com/murmumanish/College-Agent

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

# ==========================================================
#              COLLEGE INFORMATION AI AGENT
# ==========================================================
# College Knowledge Base
# ==========================================================

college_data = {

    "admission": {
        "keywords": ["admission", "apply", "application", "eligibility", "document"],

        "response":
"""
========== ADMISSION INFORMATION ==========

Admission Process :

1. Fill the Online Application Form
2. Upload Required Documents
3. Pay Registration Fee
4. Document Verification
5. Admission Confirmation

Required Documents :

• 10th Marksheet
• 12th Marksheet
• Transfer Certificate (TC)
• Migration Certificate
• Aadhaar Card
• Passport Size Photograph

Eligibility

• 10+2 Passed
• Valid Entrance Score (if applicable)
"""
    },

    "fees": {
        "keywords": ["fee", "fees", "payment", "tuition"],

        "response":
"""
========== FEE DETAILS ==========

Tuition Fee  : ₹50,000 / Year
Hostel Fee   : ₹20,000 / Year
Library Fee  : ₹2,000 / Year

Payment Methods

• UPI
• Debit Card
• Credit Card
• Net Banking
"""
    },

    "exam": {
        "keywords": ["exam", "result", "semester", "revaluation", "admit"],

        "response":
"""
========== EXAMINATION ==========

• Mid Semester Exams
• End Semester Exams
• Practical Exams
• Admit Card Download
• Result Declaration
• Revaluation Facility
"""
    },

    "scholarship": {
        "keywords": ["scholarship", "financial"],

        "response":
"""
========== SCHOLARSHIPS ==========

• NSP Scholarship

• State Scholarship

• Merit Scholarship

• SC/ST Scholarship

• Minority Scholarship
"""
    },

    "hostel": {
        "keywords": ["hostel", "mess", "room"],

        "response":
"""
========== HOSTEL ==========

Facilities

• Separate Boys & Girls Hostel
• Wi-Fi
• Mess
• RO Water
• Security
• 24×7 Electricity
"""
    },

    "placement": {
        "keywords": ["placement", "package", "company", "internship", "job"],

        "response":
"""
========== PLACEMENTS ==========

Highest Package : ₹18 LPA

Average Package : ₹5 LPA

Top Recruiters

• TCS
• Infosys
• Wipro
• Accenture
• Cognizant
"""
    },

    "library": {
        "keywords": ["library", "book", "books"],

        "response":
"""
========== LIBRARY ==========

• 50,000+ Books

• Digital Library

• Reading Hall

Timing

9:00 AM - 8:00 PM
"""
    },

    "general": {

        "keywords": [],

        "response":
"""
========== COLLEGE FACILITIES ==========

• Smart Classrooms

• Computer Labs

• Sports Complex

• Medical Room

• Cafeteria

• Auditorium
"""
    }

}

# ==========================================================
# Conversation History
# ==========================================================

history = []

# ==========================================================
# AI Agents
# ==========================================================

class AdmissionAgent:

    def handle(self):
        return college_data["admission"]["response"]


class FeesAgent:

    def handle(self):
        return college_data["fees"]["response"]


class ExamAgent:

    def handle(self):
        return college_data["exam"]["response"]


class ScholarshipAgent:

    def handle(self):
        return college_data["scholarship"]["response"]


class HostelAgent:

    def handle(self):
        return college_data["hostel"]["response"]


class PlacementAgent:

    def handle(self):
        return college_data["placement"]["response"]


class LibraryAgent:

    def handle(self):
        return college_data["library"]["response"]


class GeneralAgent:

    def handle(self):
        return college_data["general"]["response"]

# ==========================================================
# Intent Classifier
# ==========================================================

class IntentClassifier:

    def classify(self, query):

        query = query.lower()

        best_match = "general"
        max_matches = 0

        for department, details in college_data.items():

            count = 0

            for keyword in details["keywords"]:

                if keyword in query:
                    count += 1

            if count > max_matches:
                max_matches = count
                best_match = department

        return best_match


# ==========================================================
# Response Agent
# ==========================================================

class ResponseAgent:

    def __init__(self):

        self.agents = {

            "admission": AdmissionAgent(),
            "fees": FeesAgent(),
            "exam": ExamAgent(),
            "scholarship": ScholarshipAgent(),
            "hostel": HostelAgent(),
            "placement": PlacementAgent(),
            "library": LibraryAgent(),
            "general": GeneralAgent()

        }

    def respond(self, intent, question):

        answer = self.agents[intent].handle()

        # Save conversation history
        history.append({
            "Question": question,
            "Department": intent.title()
        })

        # Keep only last 5 conversations
        if len(history) > 5:
            history.pop(0)

        return answer


# ==========================================================
# Display Recent Conversation
# ==========================================================

def show_history():

    if not history:
        return

    print("\nRecent Conversation")

    print("-" * 40)

    for chat in history:

        print(f"{chat['Department']} : {chat['Question']}")

    print("-" * 40)


# ==========================================================
# Welcome Screen
# ==========================================================

def display_menu():

    print("=" * 65)
    print("COLLEGE INFORMATION AI AGENT")
    print("=" * 65)

    print("\nI can help you with:\n")

    print("1. Admission")
    print("2. Fees")
    print("3. Examination")
    print("4. Scholarship")
    print("5. Hostel")
    print("6. Placements")
    print("7. Library")
    print("8. General College Information")

    print("\nType 'history' to view previous questions.")
    print("Type 'exit' to close the chatbot.")

    print("=" * 65)

# ==========================================================
# Greeting
# ==========================================================

def greet(query):

    greetings = [
        "hi",
        "hello",
        "hey",
        "good morning",
        "good afternoon",
        "good evening"
    ]

    return query.lower() in greetings


# ==========================================================
# Unknown Query Handler
# ==========================================================

def unknown_response():

    return """
Sorry! I don't have enough information about that.

I can help you with:

• Admission
• Fees
• Examination
• Scholarships
• Hostel
• Placements
• Library
• General College Information

For further assistance, please contact the respective college department.
"""


# ==========================================================
# Main Function
# ==========================================================

def main():

    display_menu()

    classifier = IntentClassifier()
    responder = ResponseAgent()

    query = input("\nYou : ").strip()

    if not query:
        print("Please enter a valid question.")
        return

    if query.lower() == "exit":

        print("\nThank you for using the Smart College Information AI Agent.")
        print("Have a wonderful day!\n")
        return

    if query.lower() == "history":

        show_history()
        return

    if greet(query):

        print("\nBot : Hello!")
        print("How can I help you today?")
        return

    intent = classifier.classify(query)

    if intent == "general":

        general_words = [
            "college",
            "facility",
            "facilities",
            "campus"
        ]

        if not any(word in query.lower() for word in general_words):

            print(unknown_response())
            return

    print("\nSearching information...")

    answer = responder.respond(intent, query)

    print("\n" + answer)

    print("\n" + "-" * 60)

# ==========================================================
# Driver Code
# ==========================================================

if __name__ == "__main__":
    main()

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END


class StudentState(TypedDict):
    query: str
    intent: str
    response: str


def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state


def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. "
        "Students should submit the application form with all required documents."
    )
    return state


def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state


def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state


def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state


def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state


def route(state: StudentState):
    return state["intent"]


workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")

workflow.add_edge("Response Agent", END)

app = workflow.compile()


print("===== College Student Assistant =====")
query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

#pip install langgraph

from typing import TypedDict
from langgraph.graph import StateGraph, END

# -----------------------------
# Define the Graph State
# -----------------------------
class AgentState(TypedDict):
    query: str
    intent: str
    response: str


# -----------------------------
# Intent Classifier
# -----------------------------
def intent_classifier(state: AgentState):
    query = state["query"].lower()

    if "admission" in query:
        state["intent"] = "admission"
    elif "exam" in query:
        state["intent"] = "exam"
    elif "fee" in query or "fees" in query:
        state["intent"] = "fees"
    elif "scholarship" in query:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state


# -----------------------------
# Admission Agent
# -----------------------------
def admission_agent(state: AgentState):
    state["response"] = (
        "Admission Agent:\n"
        "Admission is open. Submit your application, documents, and entrance exam score."
    )
    return state


# -----------------------------
# Exam Agent
# -----------------------------
def exam_agent(state: AgentState):
    state["response"] = (
        "Exam Agent:\n"
        "The semester exam starts on 05 December."
    )
    return state


# -----------------------------
# Fees Agent
# -----------------------------
def fees_agent(state: AgentState):
    state["response"] = (
        "Fees Agent:\n"
        "The semester fee is ₹42,000."
    )
    return state


# -----------------------------
# Scholarship Agent
# -----------------------------
def scholarship_agent(state: AgentState):
    state["response"] = (
        "Scholarship Agent:\n"
        "Students with more than 85% marks are eligible for scholarships."
    )
    return state


# -----------------------------
# Response Agent
# -----------------------------
def response_agent(state: AgentState):
    print("\nFinal Response:")
    print(state["response"])
    return state


# -----------------------------
# Routing Function
# -----------------------------
def router(state: AgentState):
    return state["intent"]


# -----------------------------
# Build LangGraph
# -----------------------------
workflow = StateGraph(AgentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    router,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")
workflow.add_edge("Response Agent", END)

graph = workflow.compile()


# -----------------------------
# Run Example
# -----------------------------
query = input("Enter your query: ")

graph.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

import os
from dotenv import load_dotenv

from typing import TypedDict

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini")

# -----------------------------
# State
# -----------------------------

class AgentState(TypedDict):
    question: str
    intent: str
    answer: str


# -----------------------------
# Intent Classifier
# -----------------------------

def intent_classifier(state: AgentState):

    question = state["question"]

    prompt = f"""
You are an Intent Classifier.

Classify the question into ONLY one category.

Categories:

Admission
Exam
Fees
Scholarship

Question:
{question}

Return only category name.
"""

    response = llm.invoke([HumanMessage(content=prompt)])

    intent = response.content.strip()

    return {"intent": intent}


# -----------------------------
# Admission Agent
# -----------------------------

def admission_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Admission Agent.

Answer admission related questions.

Question:
{question}
"""

    response = llm.invoke(question)

    return {"answer": response.content}


# -----------------------------
# Exam Agent
# -----------------------------

def exam_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Exam Agent.

Answer exam related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Fees Agent
# -----------------------------

def fees_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Fees Agent.

Answer fee related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Scholarship Agent
# -----------------------------

def scholarship_agent(state: AgentState):

    question = state["question"]

    prompt = f"""
You are Scholarship Agent.

Answer scholarship related questions.

Question:
{question}
"""

    response = llm.invoke(prompt)

    return {"answer": response.content}


# -----------------------------
# Response Agent
# -----------------------------

def response_agent(state: AgentState):

    return {"answer": state["answer"]}


# -----------------------------
# Router
# -----------------------------

def router(state: AgentState):

    intent = state["intent"].lower()

    if "admission" in intent:
        return "Admission Agent"

    elif "exam" in intent:
        return "Exam Agent"

    elif "fees" in intent:
        return "Fees Agent"

    else:
        return "Scholarship Agent"


# -----------------------------
# Graph
# -----------------------------

graph = StateGraph(AgentState)

graph.add_node("Intent Classifier", intent_classifier)

graph.add_node("Admission Agent", admission_agent)
graph.add_node("Exam Agent", exam_agent)
graph.add_node("Fees Agent", fees_agent)
graph.add_node("Scholarship Agent", scholarship_agent)

graph.add_node("Response Agent", response_agent)

graph.set_entry_point("Intent Classifier")

graph.add_conditional_edges(
    "Intent Classifier",
    router,
    {
        "Admission Agent": "Admission Agent",
        "Exam Agent": "Exam Agent",
        "Fees Agent": "Fees Agent",
        "Scholarship Agent": "Scholarship Agent",
    },
)

graph.add_edge("Admission Agent", "Response Agent")
graph.add_edge("Exam Agent", "Response Agent")
graph.add_edge("Fees Agent", "Response Agent")
graph.add_edge("Scholarship Agent", "Response Agent")

graph.add_edge("Response Agent", END)

app = graph.compile()


# -----------------------------
# Run
# -----------------------------

while True:

    q = input("\nAsk Question: ")

    if q.lower() == "exit":
        break

    result = app.invoke(
        {
            "question": q,
            "intent": "",
            "answer": "",
        }
    )

    print("\nAnswer:\n")
    print(result["answer"])

Open full submission →

https://github.com/fastcoding09/AI_PROJECT/tree/main

Open full submission →

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

import os
from dotenv import load_dotenv

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END

from langchain_google_genai import ChatGoogleGenerativeAI


load_dotenv()

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")

if not GOOGLE_API_KEY:
    raise ValueError(
        "GOOGLE_API_KEY not found.\n"
        "Create a .env file and add:\n"
        "GOOGLE_API_KEY=YOUR_API_KEY"
    )



class GeminiLLM:
    """
    Wrapper class for Google Gemini.
    """

    def __init__(self):

        self.model = ChatGoogleGenerativeAI(
            model="gemini-3.5-flash",
            google_api_key=GOOGLE_API_KEY,
            temperature=0.3,
        )

    def generate(self, prompt: str) -> str:

        try:

            response = self.model.invoke(prompt)

            if isinstance(response.content, str):
                return response.content

            if isinstance(response.content, list):

                text = ""

                for block in response.content:

                    if (
                        isinstance(block, dict)
                        and block.get("type") == "text"
                    ):
                        text += block.get("text", "")

                return text.strip()

            return str(response.content)

        except Exception as e:

            return f"Error: {e}"


gemini = GeminiLLM()



# STATE


class CollegeState(TypedDict):

    query: str

    intent: str

    response: str



# PYTHON INTENT CLASSIFIER
# (NO GEMINI API CALL)


def classify_intent(query: str) -> str:

    q = query.lower()

    admission_keywords = [
        "admission",
        "apply",
        "application",
        "eligibility",
        "document",
        "admit",
        "counselling",
        "cutoff",
    ]

    exam_keywords = [
        "exam",
        "result",
        "attendance",
        "semester",
        "internal",
        "backlog",
        "syllabus",
        "schedule",
    ]

    fees_keywords = [
        "fee",
        "fees",
        "hostel fee",
        "payment",
        "refund",
        "tuition",
        "bus fee",
    ]

    scholarship_keywords = [
        "scholarship",
        "nsp",
        "merit",
        "government scholarship",
        "state scholarship",
    ]

    for word in admission_keywords:

        if word in q:
            return "admission"

    for word in exam_keywords:

        if word in q:
            return "exam"

    for word in fees_keywords:

        if word in q:
            return "fees"

    for word in scholarship_keywords:

        if word in q:
            return "scholarship"

    return "unknown"



# INTENT NODE


def intent_classifier(state: CollegeState):

    state["intent"] = classify_intent(state["query"])

    return state



# ROUTER


def router(state: CollegeState):

    return state["intent"]



# UNKNOWN AGENT


def unknown_agent(state: CollegeState):

    state["response"] = (
        "Sorry, I can only answer questions related to:\n\n"
        "• Admission\n"
        "• Examination\n"
        "• Fees\n"
        "• Scholarship"
    )

    return state

# ADMISSION AGENT


def admission_agent(state: CollegeState):
    prompt = f"""
You are a college admission assistant.

Answer only admission-related questions in simple language.

Question:
{state["query"]}
"""

    state["response"] = gemini.generate(prompt)

    return state



# EXAM AGENT


def exam_agent(state: CollegeState):

    prompt = f"""
You are the Examination Department Assistant.

Answer ONLY examination-related questions.

Topics:

- Semester Exam
- Internal Exam
- Exam Schedule
- Result
- Attendance
- Syllabus
- Backlog Exam

If the question is outside examination,
politely refuse.

Student Question:

{state["query"]}

Provide a short and professional answer.
"""

    state["response"] = gemini.generate(prompt)

    return state



# FEES AGENT


def fees_agent(state: CollegeState):

    prompt = f"""
You are the College Accounts Department.

Answer ONLY fee-related questions.

Topics:

- Tuition Fee
- Hostel Fee
- Bus Fee
- Payment Method
- Refund Policy
- Fee Receipt

If the question is unrelated,
politely refuse.

Student Question:

{state["query"]}

Give a concise answer using bullet points whenever possible.
"""

    state["response"] = gemini.generate(prompt)

    return state



# SCHOLARSHIP AGENT


def scholarship_agent(state: CollegeState):

    prompt = f"""
You are the Scholarship Help Desk.

Answer ONLY scholarship-related questions.

Topics:

- NSP
- Government Scholarship
- Merit Scholarship
- State Scholarship
- Eligibility
- Required Documents
- Scholarship Application

If the question is unrelated,
politely refuse.

Student Question:

{state["query"]}

Respond in simple language.
"""

    state["response"] = gemini.generate(prompt)

    return state




def response_agent(state: CollegeState):
    """
    Optional response formatter.

    No additional Gemini API call.
    This keeps the project faster and avoids
    consuming extra API quota.
    """

    response = state["response"].strip()

    if not response:
        response = "No response generated."

    state["response"] = response

    return state

# BUILD LANGGRAPH


builder = StateGraph(CollegeState)


# Register Nodes


builder.add_node("intent_classifier", intent_classifier)
builder.add_node("admission", admission_agent)
builder.add_node("exam", exam_agent)
builder.add_node("fees", fees_agent)
builder.add_node("scholarship", scholarship_agent)
builder.add_node("unknown", unknown_agent)
builder.add_node("response", response_agent)


# START


builder.add_edge(START, "intent_classifier")


# Conditional Routing

builder.add_conditional_edges(
    "intent_classifier",
    router,
    {
        "admission": "admission",
        "exam": "exam",
        "fees": "fees",
        "scholarship": "scholarship",
        "unknown": "unknown",
    },
)


builder.add_edge("admission", "response")
builder.add_edge("exam", "response")
builder.add_edge("fees", "response")
builder.add_edge("scholarship", "response")
builder.add_edge("unknown", "response")

# -----------------------------
# Response -> END
# -----------------------------

builder.add_edge("response", END)

# Compile Graph
graph = builder.compile()



def main():

    print("=" * 60)
    print(" College Information Multi-Agent AI agent ")
    print("=" * 60)
    print("Type 'exit' to quit.\n")

    while True:

        query = input(" Student: ").strip()

        if query.lower() in ["exit", "quit"]:

            print("\n👋 Thank you for using the  my agent !")
            break

        state = {
            "query": query,
            "intent": "",
            "response": "",
        }

        try:

            result = graph.invoke(state)

            print("\n----------------------------------------")
            print(f"Detected Intent : {result['intent']}")
            print("----------------------------------------")

            print("\n Agent:\n")
            print(result["response"])
            print()

        except Exception as e:

            print("\n❌ Error")
            print(e)
            print()


if __name__ == "__main__":
    main()

Open full submission →

import time
import random
import sys
from typing import TypedDict
from langgraph.graph import StateGraph, END


class AgentState(TypedDict):
    """This dictionary is passed along the graph. Each node can read or update it."""
    user_input: str
    intent: str
    agent_response: str
    final_output: str

 
class AdmissionAgent:
    def get_info(self) -> str:
        return (
            " [ADMISSION DESK]\n"
            "University Admissions Portal.\n\n"
            "Here is the UGC-approved admission process for the 2026 academic session:\n"
            "  1. Application: Register via the official portal (requires Aadhar integration).\n"
            "  2. Eligibility: Valid JEE Main or CUET UG score is mandatory for B.Tech.\n"
            "  3. Documentation: Upload 10th & 12th Marksheets, Transfer Certificate (TC),\n"
            "     and Category Certificate (if applicable).\n"
            "  4. Fee Payment: Pay the ₹2,000 non-refundable counseling fee via UPI or NetBanking.\n\n"
            " Pro-Tip: Seat allocation is based on centralized counseling rounds (JoSAA/CSAB). "
            "Keep an eye on the portal for cutoff dates!"
        )

class ExamAgent:
    def get_info(self) -> str:
        return (
            " [EXAMINATION CELL]\n"
            "Important Updates for the Current Odd Semester (Winter):\n\n"
            "  • End-Semester Exams: Commencing strictly from 10th December.\n"
            "  • Hall Tickets: Will be available on the college portal 5 days prior.\n"
            "  • Dues Clearance: Ensure all library and hostel dues are cleared to download your Admit Card.\n\n"
            " Note: A minimum of 75% attendance is strictly required to appear for examinations as per university norms."
        )

class FeesAgent:
    def get_info(self) -> str:
        return (
            " [ACCOUNTS & BILLING]\n"
            "Fee Structure for First-Year B.Tech (Per Semester):\n\n"
            "  • Tuition Fee         : ₹65,000\n"
            "  • Development Fund    : ₹12,000\n"
            "  • Hostel & Mess (Avg) : ₹35,000\n"
            "  • Caution Money       : ₹5,000 (Refundable)\n"
            "  ----------------------------------\n"
            "  Total Estimated       : ₹1,17,000\n\n"
        )

class ScholarshipAgent:
    def get_info(self) -> str:
        return (
            " [SCHOLARSHIP & WELFARE]\n"
            "We believe financial constraints should not hinder education. Available schemes:\n\n"
            "  1. Merit-cum-Means (MCM): 50% tuition waiver for students with family income < ₹5 LPA and CGPA > 8.0.\n"
            "  2. State/Central Schemes: Apply directly via the National Scholarship Portal (NSP).\n"
            "  3. Jharkhand eKalyan: Post-matric scholarship for eligible SC/ST/BC students domiciled in Jharkhand.\n"
            "  4. PMSSS: Special scheme for students from J&K and Ladakh.\n"
            "  5. Category Waivers: As per Govt. of India reservation guidelines for SC/ST/OBC (NCL).\n\n"
            "Visit the Dean of Student Welfare (DSW) office for manual form verifications."
        )

class SemanticRouter:
    def __init__(self):
        self.intent_map = {
            "admission": ["admission", "apply", "join", "enroll", "cutoff", "jee", "cuet", "process"],
            "exam": ["exam", "test", "admit card", "hall ticket", "date sheet", "marks", "result", "semester"],
            "fees": ["fee", "cost", "money", "pay", "tuition", "hostel fee", "loan", "dues"],
            "scholarship": ["scholarship", "waiver", "concession", "financial aid", "nsp", "mcm"],
            "help": ["help", "options", "menu", "what can you do"],
            "exit": ["bye", "exit", "quit", "leave", "close"]
        }

    def detect_intent(self, text: str) -> str:
        text = text.lower().strip()
        for intent, keywords in self.intent_map.items():
            if any(keyword in text for keyword in keywords):
                return intent
        return "unknown"


def node_intent_classifier(state: AgentState):
    """Classifies the user input and updates the state."""
    router = SemanticRouter()
    intent = router.detect_intent(state["user_input"])
    return {"intent": intent}

def node_admission_agent(state: AgentState):
    return {"agent_response": AdmissionAgent().get_info()}

def node_exam_agent(state: AgentState):
    return {"agent_response": ExamAgent().get_info()}

def node_fees_agent(state: AgentState):
    return {"agent_response": FeesAgent().get_info()}

def node_scholarship_agent(state: AgentState):
    return {"agent_response": ScholarshipAgent().get_info()}

def node_response_agent(state: AgentState):
    """Formats the final response based on what was gathered or if it was a system command."""
    intent = state.get("intent")
    
    if intent == "exit":
        messages = [
            "Session terminated. Best of luck with your academic journey!",
            "Goodbye! Feel free to return if you have more questions. ",
            "Logging off."
        ]
        final_text = random.choice(messages)
    elif intent == "help":
        final_text = (
            " [SYSTEM HELPER]\n"
            "I am the AI Assistant for the University.\n"
            "Try asking me things like:\n"
            "  • How do I apply for admission?\n"
            "  • When are the semester exams?\n"
            "  • What is the B.Tech fee structure?\n"
            "  • Are there any scholarships available?\n\n"
            "Type 'exit' to close the session."
        )
    elif intent == "unknown":
        final_text = (
            " [SYSTEM] I couldn't quite understand that query.\n"
            "Currently, I am programmed to assist with Admissions, Exams, Fees, and Scholarships.\n"
            "Please try rephrasing or type 'help' to see your options."
        )
    else:
        
        final_text = state.get("agent_response", "Error generating response.")

    return {"final_output": final_text}

def route_by_intent(state: AgentState) -> str:
    """Reads the intent from the state and determines the next node."""
    intent = state["intent"]
    valid_agents = ["admission", "exam", "fees", "scholarship"]
    
    if intent in valid_agents:
        return f"{intent}_agent" 
    else:
        return "response_agent" 


workflow = StateGraph(AgentState)

workflow.add_node("intent_classifier", node_intent_classifier)
workflow.add_node("admission_agent", node_admission_agent)
workflow.add_node("exam_agent", node_exam_agent)
workflow.add_node("fees_agent", node_fees_agent)
workflow.add_node("scholarship_agent", node_scholarship_agent)
workflow.add_node("response_agent", node_response_agent)

workflow.set_entry_point("intent_classifier")

workflow.add_conditional_edges(
    "intent_classifier",
    route_by_intent,
    {
        "admission_agent": "admission_agent",
        "exam_agent": "exam_agent",
        "fees_agent": "fees_agent",
        "scholarship_agent": "scholarship_agent",
        "response_agent": "response_agent" 
    }
)

workflow.add_edge("admission_agent", "response_agent")
workflow.add_edge("exam_agent", "response_agent")
workflow.add_edge("fees_agent", "response_agent")
workflow.add_edge("scholarship_agent", "response_agent")
workflow.add_edge("response_agent", END)

app = workflow.compile()

def print_delayed(text: str, delay: float = 0.015):
    """Creates a professional typing effect in the terminal."""
    for char in text:
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(delay)
    print("\n")

def main():
    print("=" * 60)
    print("  LANGGRAPH BASED UNIVERSITY AI SYSTEM")
    print("=" * 60)
    
    user_name = input("\n Enter your name to initiate session: ").strip().title()
    if not user_name:
        user_name = "Student"

    welcome_msg = (
        f"\nWelcome, {user_name}! I am the centralized AI Assistant.\n"
        "How can I help you today? (Type 'help' for options)"
    )
    print_delayed(welcome_msg)

    while True:
        user_input = input(f"\n{user_name} > ")
        if not user_input.strip():
            continue

        initial_state = {"user_input": user_input, "intent": "", "agent_response": "", "final_output": ""}
        result_state = app.invoke(initial_state)

        time.sleep(0.3)
        print("-" * 60)
        
        print_delayed(result_state["final_output"])
        print("-" * 60)

        if result_state["intent"] == "exit":
            break

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n Exiting system...")
        sys.exit(0)

Open full submission →

https://github.com/kishor7667/LangGraph-University-AI-Chatbot-v2.git

Open full submission →

https://github.com/rocky62077/collage_info_Ai

Open full submission →

https://github.com/vedp2521154/University_Management_System

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")
import sys
import time
from typing import TypedDict
from langgraph.graph import StateGraph, END

# 1. STATE DEFINE
class AgentState(TypedDict):
    user_input: str
        intent: str
            agent_response: str
                final_output: str

                # 2. ALL NODES
                def node_intent_classifier(state: AgentState) -> AgentState:
                    user_input = state["user_input"].lower()
                        
                            if "admission" in user_input:
                                    state["intent"] = "admission"
                                        elif "exam" in user_input or "paper" in user_input:
                                                state["intent"] = "exam"
                                                    elif "fees" in user_input or "payment" in user_input:
                                                            state["intent"] = "fees"
                                                                elif "scholarship" in user_input or "ntse" in user_input or "merit" in user_input:
                                                                        state["intent"] = "scholarship"
                                                                            elif "exit" in user_input or "bye" in user_input:
                                                                                    state["intent"] = "exit"
                                                                                        elif "help" in user_input:
                                                                                                state["intent"] = "help"
                                                                                                    else:
                                                                                                            state["intent"] = "general"
                                                                                                                return state

                                                                                                                def node_admission_agent(state: AgentState) -> AgentState:
                                                                                                                    state["agent_response"] = (
                                                                                                                            "Admission Process:\n"
                                                                                                                                    "1. Forms July 2026 me open honge\n"
                                                                                                                                            "2. Website: university.edu/admission\n"
                                                                                                                                                    "3. Documents: 10th, 12th Marksheet, Aadhar"
                                                                                                                                                        )
                                                                                                                                                            return state

                                                                                                                                                            def node_exam_agent(state: AgentState) -> AgentState:
                                                                                                                                                                state["agent_response"] = (
                                                                                                                                                                        "Exam Info:\n"
                                                                                                                                                                                "1. Mid-Sem: September 2026\n"
                                                                                                                                                                                        "2. Final: December 2026\n"
                                                                                                                                                                                                "3. Hall Ticket exam se 7 din pehle portal par"
                                                                                                                                                                                                    )
                                                                                                                                                                                                        return state

                                                                                                                                                                                                        def node_fees_agent(state: AgentState) -> AgentState:
                                                                                                                                                                                                            state["agent_response"] = (
                                                                                                                                                                                                                    "Fees Structure:\n"
                                                                                                                                                                                                                            "1. Total Fees: 2 Installment me\n"
                                                                                                                                                                                                                                    "2. Last Date: 30th July 2026\n"
                                                                                                                                                                                                                                            "3. Payment: Online Portal se"
                                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                                    return state

                                                                                                                                                                                                                                                    def node_scholarship_agent(state: AgentState) -> AgentState:
                                                                                                                                                                                                                                                        state["agent_response"] = (
                                                                                                                                                                                                                                                                "Scholarship Info:\n"
                                                                                                                                                                                                                                                                        "1. NTSE Scholarship: Oct-Nov me form\n"
                                                                                                                                                                                                                                                                                "2. Merit Scholarship: 90%+ walo ke liye\n"
                                                                                                                                                                                                                                                                                        "3. Apply: university.edu/scholarship"
                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                return state

                                                                                                                                                                                                                                                                                                def node_response_agent(state: Agent

Open full submission →

from langchain_groq import ChatGroq
from langgraph.graph import StateGraph, START, END
from typing import TypedDict

GROQ_API_KEY = "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"

model = ChatGroq(
    api_key=GROQ_API_KEY,
    model="llama-3.3-70b-versatile",
    temperature=0.7,
)

class GraphState(TypedDict):
    input: str
    output: str


def chatbot(state: GraphState) -> dict:
  
    response = model.invoke(state["input"])
    return {"output": response.content}


builder = StateGraph(GraphState)
builder.add_node("chatbot", chatbot)
builder.add_edge(START, "chatbot")
builder.add_edge("chatbot", END)
graph = builder.compile()

def main():
    print("Simple AI Agent")
    print("Type 'exit' to quit.\n")

    while True:
        try:
            message = input("You: ")
        except (EOFError, KeyboardInterrupt):
            print()
            break

        if message.strip().lower() == "exit":
            break

        result = graph.invoke({"input": message})

        print(f"\nAI: {result['output']}\n")

if __name__ == "__main__":
    main()

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END

# -----------------------------
# State Definition
# -----------------------------
class AgentState(TypedDict):
    query: str
        intent: str
            response: str


            # -----------------------------
            # Intent Classifier
            # -----------------------------
            def intent_classifier(state: AgentState):
                query = state["query"].lower()

                    if "admission" in query:
                            state["intent"] = "admission"
                                elif "exam" in query:
                                        state["intent"] = "exam"
                                            elif "fee" in query or "fees" in query:
                                                    state["intent"] = "fees"
                                                        elif "scholarship" in query:
                                                                state["intent"] = "scholarship"
                                                                    else:
                                                                            state["intent"] = "unknown"

                                                                                return state


                                                                                # -----------------------------
                                                                                # Admission Agent
                                                                                # -----------------------------
                                                                                def admission_agent(state: AgentState):
                                                                                    state["response"] = (
                                                                                            "Admission Agent:\n"
                                                                                                    "Admission is open. Submit your application, documents, and entrance exam score."
                                                                                                        )
                                                                                                            return state


                                                                                                            # -----------------------------
                                                                                                            # Exam Agent
                                                                                                            # -----------------------------
                                                                                                            def exam_agent(state: AgentState):
                                                                                                                state["response"] = (
                                                                                                                        "Exam Agent:\n"
                                                                                                                                "The semester exam starts on 15 December."
                                                                                                                                    )
                                                                                                                                        return state


                                                                                                                                        # -----------------------------
                                                                                                                                        # Fees Agent
                                                                                                                                        # -----------------------------
                                                                                                                                        def fees_agent(state: AgentState):
                                                                                                                                            state["response"] = (
                                                                                                                                                    "Fees Agent:\n"
                                                                                                                                                            "The semester fee is ₹50,000."
                                                                                                                                                                )
                                                                                                                                                                    return state


                                                                                                                                                                    # -----------------------------
                                                                                                                                                                    # Scholarship Agent
                                                                                                                                                                    # -----------------------------
                                                                                                                                                                    def scholarship_agent(state: AgentState):
                                                                                                                                                                        state["response"] = (
                                                                                                                                                                                "Scholarship Agent:\n"
                                                                                                                                                                                        "Students with more than 85% marks are eligible for scholarships."
                                                                                                                                                                                            )
                                                                                                                                                                                                return state


                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                # Response Agent
                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                def response_agent(state: AgentState):
                                                                                                                                                                                                    print("\nFinal Response:")
                                                                                                                                                                                                        print(state["response"])
                                                                                                                                                                                                            return state


                                                                                                                                                                                                            # -----------------------------
                                                                                                                                                                                                            # Routing Function
                                                                                                                                                                                                            # -----------------------------
                                                                                                                                                                                                            def router(state: AgentState):
                                                                                                                                                                                                                return state["intent"]


                                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                                # Build LangGraph
                                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                                workflow = StateGraph(AgentState)

                                                                                                                                                                                                                workflow.add_node("Intent Classifier", intent_classifier)
                                                                                                                                                                                                                workflow.add_node("Admission Agent", admission_agent)
                                                                                                                                                                                                                workflow.add_node("Exam Agent", exam_agent)
                                                                                                                                                                                                                workflow.add_node("Fees Agent", fees_agent)
                                                                                                                                                                                                                workflow.add_node("Scholarship Agent", scholarship_agent)
                                                                                                                                                                                                                workflow.add_node("Response Agent", response_agent)

                                                                                                                                                                                                                workflow.set_entry_point("Intent Classifier")

                                                                                                                                                                                                                workflow.add_conditional_edges(
                                                                                                                                                                                                                    "Intent Classifier",
                                                                                                                                                                                                                        router,
                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                    "admission": "Admission Agent",
                                                                                                                                                                                                                                            "exam": "Exam Agent",
                                                                                                                                                                                                                                                    "fees": "Fees Agent",
                                                                                                                                                                                                                                                            "scholarship": "Scholarship Agent",
                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                workflow.add_edge("Admission Agent", "Response Agent")
                                                                                                                                                                                                                                                                workflow.add_edge("Exam Agent", "Response Agent")
                                                                                                                                                                                                                                                                workflow.add_edge("Fees Agent", "Response Agent")
                                                                                                                                                                                                                                                                workflow.add_edge("Scholarship Agent", "Response Agent")
                                                                                                                                                                                                                                                                workflow.add_edge("Response Agent", END)

                                                                                                                                                                                                                                                                graph = workflow.compile()


                                                                                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                                                                                # Run Example
                                                                                                                                                                                                                                                                # -----------------------------
                                                                                                                                                                                                                                                                query = input("Enter your query: ")

                                                                                                                                                                                                                                                                graph.invoke(
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                            "query": query,
                                                                                                                                                                                                                                                                                    "intent": "",
                                                                                                                                                                                                                                                                                            "response": ""
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                )

Open full submission →

class AdmissionAgent:
    def reply(self):
        return (
            "🎓 Admission Agent\n"
            "Admission Process:\n"
            "1. Fill the online application form.\n"
            "2. Upload required documents.\n"
            "3. Pay the registration fee.\n"
            "4. Wait for admission confirmation."
        )


class ExamAgent:
    def reply(self):
        return (
            "📝 Exam Agent\n"
            "Exam Information:\n"
            "1. Mid Semester Exam\n"
            "2. End Semester Exam\n"
            "3. Practical Examination\n"
            "4. Results will be declared on the portal."
        )


class FeesAgent:
    def reply(self):
        return (
            "💰 Fees Agent\n"
            "Fee Details:\n"
            "1. Tuition Fee\n"
            "2. Hostel Fee\n"
            "3. Library Fee\n"
            "4. Fees can be paid online or offline."
        )


class ScholarshipAgent:
    def reply(self):
        return (
            "🏆 Scholarship Agent\n"
            "Scholarship Information:\n"
            "1. Merit Scholarship\n"
            "2. Government Scholarship\n"
            "3. Sports Scholarship\n"
            "4. Apply before the last date."
        )


class ResponseAgent:
    def respond(self, message):
        print("\n--------------------------------")
        print(message)
        print("--------------------------------\n")


class IntentClassifier:
    def classify(self, text):
        text = text.lower()

        if any(word in text for word in ["admission", "apply", "college", "document"]):
            return "admission"

        elif any(word in text for word in ["exam", "test", "result", "marks"]):
            return "exam"

        elif any(word in text for word in ["fee", "fees", "payment", "money"]):
            return "fees"

        elif any(word in text for word in ["scholarship", "financial aid", "grant"]):
            return "scholarship"

        else:
            return "unknown"


admission = AdmissionAgent()
exam = ExamAgent()
fees = FeesAgent()
scholarship = ScholarshipAgent()
classifier = IntentClassifier()
response = ResponseAgent()

print("========================================")
print(" College Information Multi-Agent System ")
print("========================================")

while True:
    user = input("\nYou: ")

    if user.lower() in ["exit", "quit", "bye"]:
        print("\nBot: Thank you for using the system. Goodbye!")
        break

    elif user.lower() in ["hi", "hello", "hey", "hii", "good morning", "good evening"]:
        response.respond(
            "👋 Hello! Welcome to the College Information System.\n"
            "You can ask me about:\n"
            "- Admission\n"
            "- Exams\n"
            "- Fees\n"
            "- Scholarships\n"
            "Type 'exit' to quit."
        )
        continue

    intent = classifier.classify(user)

    if intent == "admission":
        response.respond(admission.reply())

    elif intent == "exam":
        response.respond(exam.reply())

    elif intent == "fees":
        response.respond(fees.reply())

    elif intent == "scholarship":
        response.respond(scholarship.reply())

    else:
        response.respond(
            "❌ Sorry, I couldn't understand your request.\n"
            "Please ask about Admission, Exams, Fees, or Scholarships."
        )

Open full submission →

class AdmissionAgent:
    def reply(self):
        return (
            " Admission Agent\n"
            "Admission Process:\n"
            "1. Fill online application.\n"
            "2. Upload documents.\n"
            "3. Pay registration fee.\n"
            "4. Wait for confirmation."
            "Contact Information:",
                " - Admission Office Helpline: +91-987654xxxx",
                " - Email: admissions@college.edu",

                "Facilities for New Students:",
                " - Orientation program in August",
                " - Hostel allotment after admission confirmation",
                " - Student ID card issued within 7 days"
                "Eligibility Criteria:",
                " - Minimum 50% marks in 12th (PCM for engineering courses)",
                " - Reservation rules as per government norms (SC/ST/OBC/EWS)",

                "Admission Process:",
                " - Online application form submission",
                " - Entrance exam / merit list",
                " - Counseling and seat allotment",

                "Important Dates:",
                " - Application Start: June 1",
                " - Last Date to Apply: July 15",
                " - Counseling: August",
        )


class ExamAgent:
    def reply(self):
        return (
            " Exam Agent\n"
            "Semester exams start from 10 December.\n"
            "Admit card will be available 5 days before the exam."
        )


class FeesAgent:
    def reply(self):
        return (
            " Fees Agent\n"
            "B.Tech First Year Fees:\n"
            "Tuition Fee : ₹85,000\n"
            "Hostel Fee  : ₹45,000\n"
            "Registration: ₹5,000"
        )


class ScholarshipAgent:
    def reply(self):
        return (
            "🎓 Scholarship Agent\n"
            "Available Scholarships:\n"
            "- Merit Scholarship\n"
            "- SC/ST Scholarship\n"
            "- OBC Scholarship\n"
        
        )


class IntentClassifier:

    def detect(self, text):
        text = text.lower()

        if "admission" in text:
            return "admission"

        elif "exam" in text:
            return "exam"

        elif "fee" in text or "fees" in text:
            return "fees"

        elif "scholarship" in text:
            return "scholarship"

        elif text in ["bye", "exit", "quit"]:
            return "exit"

        else:
            return "unknown"


class ResponseAgent:

    def respond(self, intent):

        if intent == "admission":
            return AdmissionAgent().reply()

        elif intent == "exam":
            return ExamAgent().reply()

        elif intent == "fees":
            return FeesAgent().reply()

        elif intent == "scholarship":
            return ScholarshipAgent().reply()

        elif intent == "exit":
            return " Thank you! Have a nice day."

        else:
            return (" Sorry! I can help only with:\n"
                    "- Admission\n"
                    "- Exam\n"
                    "- Fees\n"
                    "- Scholarship")


print("=" * 45)
print(" UNIVERSITY AI MULTI-AGENT SYSTEM")
print("=" * 45)

print("\nHello! Welcome.")
print("Ask about Admission, Exam, Fees or Scholarship.")
print("Type 'bye' to exit.\n")

classifier = IntentClassifier()
response = ResponseAgent()

while True:

    user = input("You : ")

    intent = classifier.detect(user)

    print("\nBot :")
    print(response.respond(intent))
    print()

    if intent == "exit":
        break

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, START, END


class CollegeState(TypedDict):
    query: str
    category: str
    department: str
    response: str
    follow_up: str


BRANCHES = {
    "cse": "CSE",
    "ece": "ECE",
    "eee": "EEE",
    "mech": "MECH",
    "civil": "CIVIL",
}

def classify(state: CollegeState):

    query = state["query"].lower()

    if any(x in query for x in ["fee", "fees", "payment", "cost"]):
        category = "fees"

    elif "scholarship" in query:
        category = "scholarship"

    elif any(x in query for x in ["admission", "apply", "jee", "eligibility", "cutoff"]):
        category = "admission"

    elif any(x in query for x in ["placement", "salary", "package", "job", "recruiter"]):
        category = "placement"

    elif any(x in query for x in ["hostel", "mess", "room"]):
        category = "hostel"

    elif any(x in query for x in ["library", "lab", "wifi", "facility"]):
        category = "infrastructure"

    elif any(x in query for x in ["exam", "semester", "result", "routine"]):
        category = "exam"

    else:
        category = "general"

    department = "General"

    for short, full in BRANCHES.items():
        if short in query:
            department = full
            break

    return {
        "category": category,
        "department": department
    }


def followup(state: CollegeState):

    msg = ""

    if state["category"] == "general":
        msg = (
            "You can ask about Admission, Fees, Scholarship, "
            "Placement, Hostel, Infrastructure or Exam."
        )

    return {"follow_up": msg}

def admission_agent(state: CollegeState):

    return {
        "response":
        "Admission is through JEE Main/JCECE counselling.\n"
        "Minimum 45% marks in PCM are required."
    }


def fees_agent(state: CollegeState):

    fees = {
        "CSE": "₹66,425/year",
        "ECE": "₹66,425/year",
        "EEE": "₹65,000/year",
        "MECH": "₹65,000/year",
        "CIVIL": "₹65,000/year",
    }

    text = "Annual college fees range between ₹65,000 - ₹66,425."

    if state["department"] in fees:
        text += f"\n\n{state['department']} Fees : {fees[state['department']]}"

    return {"response": text}


def scholarship_agent(state: CollegeState):

    return {
        "response":
        "Eligible students can apply for scholarships through the "
        "state scholarship portal before the last date by submitting "
        "all required documents."
    }


def placement_agent(state: CollegeState):

    return {
        "response":
        "Median Package : ₹3.75 LPA\n"
        "Highest Package : Around ₹6-8 LPA\n"
        "Recruiters : IT and Core Companies."
    }


def hostel_agent(state: CollegeState):

    return {
        "response":
        "Hostel Fee : ₹21,000/year\n"
        "Mess Fee : ₹3,000/month"
    }


def infrastructure_agent(state: CollegeState):

    return {
        "response":
        "Facilities Available:\n"
        "- Library\n"
        "- WiFi Campus\n"
        "- Computer Labs\n"
        "- Civil Lab\n"
        "- Mechanical Workshop\n"
        "- Electrical Lab"
    }


def exam_agent(state: CollegeState):

    return {
        "response":
        "Semester System\n"
        "Exam Fee : ₹2000\n"
        "Results are published on the college website."
    }


def general_agent(state: CollegeState):

    return {
        "response":
        "Dumka Engineering College was established in 2013.\n"
        "Departments offered:\n"
        "• CSE\n"
        "• ECE\n"
        "• EEE\n"
        "• Mechanical\n"
        "• Civil"
    }

def formatter(state: CollegeState):

    title = state["category"].upper()

    if state["department"] != "General":
        title += f" ({state['department']})"

    output = []
    output.append("=" * 50)
    output.append(title)
    output.append("=" * 50)
    output.append(state["response"])

    if state["follow_up"]:
        output.append("\nSuggestion:")
        output.append(state["follow_up"])

    return {
        "response": "\n".join(output)
    }
def router(state: CollegeState):
    return state["category"]

graph = StateGraph(CollegeState)

graph.add_node("Classifier", classify)
graph.add_node("FollowUp", followup)

graph.add_node("Admission", admission_agent)
graph.add_node("Fees", fees_agent)
graph.add_node("Scholarship", scholarship_agent)
graph.add_node("Placement", placement_agent)
graph.add_node("Hostel", hostel_agent)
graph.add_node("Infrastructure", infrastructure_agent)
graph.add_node("Exam", exam_agent)
graph.add_node("General", general_agent)

graph.add_node("Formatter", formatter)

graph.add_edge(START, "Classifier")
graph.add_edge("Classifier", "FollowUp")

graph.add_conditional_edges(
    "FollowUp",
    router,
    {
        "admission": "Admission",
        "fees": "Fees",
        "scholarship": "Scholarship",
        "placement": "Placement",
        "hostel": "Hostel",
        "infrastructure": "Infrastructure",
        "exam": "Exam",
        "general": "General",
    },
)

graph.add_edge("Admission", "Formatter")
graph.add_edge("Fees", "Formatter")
graph.add_edge("Scholarship", "Formatter")
graph.add_edge("Placement", "Formatter")
graph.add_edge("Hostel", "Formatter")
graph.add_edge("Infrastructure", "Formatter")
graph.add_edge("Exam", "Formatter")
graph.add_edge("General", "Formatter")

graph.add_edge("Formatter", END)

app = graph.compile()

def main():

    print("=" * 60)
    print("      DUMKA ENGINEERING COLLEGE AI ASSISTANT")
    print("=" * 60)

    while True:

        query = input("\nYou : ")

        if query.lower() in ["exit", "quit"]:
            print("Goodbye!")
            break

        result = app.invoke(
            {
                "query": query,
                "category": "",
                "department": "",
                "response": "",
                "follow_up": "",
            }
        )

        print("\nAssistant:\n")
        print(result["response"])


if __name__ == "__main__":
    main()

Open full submission →

# pip install langgraph 

from typing import TypedDict
from langgraph.graph import StateGraph,START,END

# -------------------------
# State Definition
# -------------------------
class AgentState(TypedDict):
    query: str
        intent: str
            response: str


            # -------------------------
            # Intent Classifier
            # -------------------------
            def intent_classifier(state):
                query = state["query"].lower()

                    if "admission" in query:
                            state["intent"] = "admission"
                                elif "exam" in query:
                                        state["intent"] = "exam"
                                            elif "fee" in query:
                                                    state["intent"] = "fees"
                                                        elif "scholarship" in query:
                                                                state["intent"] = "scholarship"
                                                                    else:
                                                                            state["intent"] = "unknown"

                                                                                return state


                                                                                # -------------------------
                                                                                # Specialized Agents
                                                                                # -------------------------
                                                                                def admission_agent(state):
                                                                                    state["response"] = "Admission starts from 1st July."
                                                                                        return state


                                                                                        def exam_agent(state):
                                                                                            state["response"] = "Exams begin from 10th December."
                                                                                                return state


                                                                                                def fees_agent(state):
                                                                                                    state["response"] = "Semester fee is Rs. 50,000."
                                                                                                        return state


                                                                                                        def scholarship_agent(state):
                                                                                                            state["response"] = "Scholarship available for students scoring above 85%."
                                                                                                                return state


                                                                                                                # -------------------------
                                                                                                                # Response Agent
                                                                                                                # -------------------------
                                                                                                                def response_agent(state):
                                                                                                                    print("\n========== RESPONSE ==========")
                                                                                                                        print(state["response"])
                                                                                                                            return state


                                                                                                                            # -------------------------
                                                                                                                            # Build LangGraph
                                                                                                                            # -------------------------
                                                                                                                            graph = StateGraph(AgentState)

                                                                                                                            graph.add_node("IntentClassifier", intent_classifier)
                                                                                                                            graph.add_node("AdmissionAgent", admission_agent)
                                                                                                                            graph.add_node("ExamAgent", exam_agent)
                                                                                                                            graph.add_node("FeesAgent", fees_agent)
                                                                                                                            graph.add_node("ScholarshipAgent", scholarship_agent)
                                                                                                                            graph.add_node("ResponseAgent", response_agent)

                                                                                                                            graph.set_entry_point("IntentClassifier")


                                                                                                                            # Routing Logic
                                                                                                                            def router(state):
                                                                                                                                return state["intent"]


                                                                                                                                graph.add_conditional_edges(
                                                                                                                                    "IntentClassifier",
                                                                                                                                        router,
                                                                                                                                            {
                                                                                                                                                    "admission": "AdmissionAgent",
                                                                                                                                                            "exam": "ExamAgent",
                                                                                                                                                                    "fees": "FeesAgent",
                                                                                                                                                                            "scholarship": "ScholarshipAgent",
                                                                                                                                                                                },
                                                                                                                                                                                )

                                                                                                                                                                                graph.add_edge("AdmissionAgent", "ResponseAgent")
                                                                                                                                                                                graph.add_edge("ExamAgent", "ResponseAgent")
                                                                                                                                                                                graph.add_edge("FeesAgent", "ResponseAgent")
                                                                                                                                                                                graph.add_edge("ScholarshipAgent", "ResponseAgent")

                                                                                                                                                                                graph.add_edge("ResponseAgent", END)

                                                                                                                                                                                app = graph.compile()


                                                                                                                                                                                # -------------------------
                                                                                                                                                                                # Run Example
                                                                                                                                                                                # -------------------------
                                                                                                                                                                                query = input("Enter your query: ")

                                                                                                                                                                                app.invoke({
                                                                                                                                                                                    "query": query,
                                                                                                                                                                                        "intent": "",
                                                                                                                                                                                            "response": ""
                                                                                                                                                                                            })

Open full submission →

# ==============================
# AI College Assistant Agent
# Single File Python Program
# ==============================

class AdmissionAgent:
    def handle(self, query):
            return (
                        "\n----- Admission Agent -----\n"
                                    "Admission Information:\n"
                                                "- Admission starts from June.\n"
                                                            "- Required Documents:\n"
                                                                        "  • 10th Marksheet\n"
                                                                                    "  • 12th Marksheet\n"
                                                                                                "  • Aadhaar Card\n"
                                                                                                            "  • Passport Size Photo\n"
                                                                                                                        "  • Migration Certificate\n"
                                                                                                                                )


                                                                                                                                class ExamAgent:
                                                                                                                                    def handle(self, query):
                                                                                                                                            return (
                                                                                                                                                        "\n----- Exam Agent -----\n"
                                                                                                                                                                    "Exam Information:\n"
                                                                                                                                                                                "- Mid Semester Exam: October\n"
                                                                                                                                                                                            "- End Semester Exam: December\n"
                                                                                                                                                                                                        "- Minimum Attendance: 75%\n"
                                                                                                                                                                                                                )


                                                                                                                                                                                                                class FeesAgent:
                                                                                                                                                                                                                    def handle(self, query):
                                                                                                                                                                                                                            return (
                                                                                                                                                                                                                                        "\n----- Fees Agent -----\n"
                                                                                                                                                                                                                                                    "Fee Information:\n"
                                                                                                                                                                                                                                                                "- Admission Fee: ₹10,000\n"
                                                                                                                                                                                                                                                                            "- Semester Fee: ₹45,000\n"
                                                                                                                                                                                                                                                                                        "- Hostel Fee: ₹20,000\n"
                                                                                                                                                                                                                                                                                                )


                                                                                                                                                                                                                                                                                                class ScholarshipAgent:
                                                                                                                                                                                                                                                                                                    def handle(self, query):
                                                                                                                                                                                                                                                                                                            return (
                                                                                                                                                                                                                                                                                                                        "\n----- Scholarship Agent -----\n"
                                                                                                                                                                                                                                                                                                                                    "Scholarship Information:\n"
                                                                                                                                                                                                                                                                                                                                                "- Merit Scholarship\n"
                                                                                                                                                                                                                                                                                                                                                            "- NSP Scholarship\n"
                                                                                                                                                                                                                                                                                                                                                                        "- SC/ST Scholarship\n"
                                                                                                                                                                                                                                                                                                                                                                                    "- OBC Scholarship\n"
                                                                                                                                                                                                                                                                                                                                                                                            )


                                                                                                                                                                                                                                                                                                                                                                                            class IntentClassifier:

                                                                                                                                                                                                                                                                                                                                                                                                def classify(self, query):

                                                                                                                                                                                                                                                                                                                                                                                                        query = query.lower()

                                                                                                                                                                                                                                                                                                                                                                                                                if any(word in query for word in
                                                                                                                                                                                                                                                                                                                                                                                                                               ["admission", "admit", "apply", "document", "eligibility"]):
                                                                                                                                                                                                                                                                                                                                                                                                                                           return "admission"

                                                                                                                                                                                                                                                                                                                                                                                                                                                   elif any(word in query for word in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ["exam", "semester", "attendance", "result"]):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                return "exam"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        elif any(word in query for word in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ["fee", "fees", "payment", "cost"]):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return "fees"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             elif any(word in query for word in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ["scholarship", "nsp", "financial", "stipend"]):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return "scholarship"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  else:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              return "unknown"


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ResponseAgent:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  def generate(self, response):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("\n==============================")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  print("Response Agent")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("==============================")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  print(response)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("==============================\n")


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          def main():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              classifier = IntentClassifier()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  admission = AdmissionAgent()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      exam = ExamAgent()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fees = FeesAgent()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scholarship = ScholarshipAgent()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  responder = ResponseAgent()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      print("=========================================")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("      AI College Assistant Agent")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              print("=========================================")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  while True:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          query = input("\nEnter your Question (exit to quit): ")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if query.lower() == "exit":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              print("\nProgram Ended.")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  intent = classifier.classify(query)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if intent == "admission":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      response = admission.handle(query)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elif intent == "exam":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          response = exam.handle(query)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elif intent == "fees":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              response = fees.handle(query)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      elif intent == "scholarship":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  response = scholarship.handle(query)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          else:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      response = "Sorry! I couldn't understand your query."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              responder.generate(response)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if __name__ == "__main__":
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  main()

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END


class StudentState(TypedDict):
    query: str
    intent: str
    response: str


def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state


def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. "
        "Students should submit the application form with all required documents."
    )
    return state


def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state


def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state


def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state


def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state


def route(state: StudentState):
    return state["intent"]


workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")

workflow.add_edge("Response Agent", END)

app = workflow.compile()


print("===== College Student Assistant =====")
query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

from typing import TypedDict, List, Dict

# ==========================================
# 1. Define the Shared State
# ==========================================
class AgentState(TypedDict):
    user_input: str
    intents: List[str]
    research_plan: List[str]
    gathered_data: List[str]
    final_response: str

# ==========================================
# 2. The Planner Agent (Your Code, slightly integrated)
# ==========================================
class PlannerAgent:
    def __init__(self):
        self.intent_keywords = {
            "course": ["course", "btech", "cse", "syllabus", "duration"],
            "facilities": ["hostel", "library", "wifi", "canteen"],
            "events": ["event", "hackathon", "placement", "deadline"],
            "support": ["help", "scholarship", "counseling"]
        }

    def detect_intents(self, query: str) -> List[str]:
        query = query.lower()
        detected = [intent for intent, keywords in self.intent_keywords.items() 
                    if any(word in query for word in keywords)]
        return detected if detected else ["general"]

    def create_plan(self, intents: List[str]) -> List[str]:
        plan = []
        for intent in intents:
            if intent == "course":
                plan.extend(["Search Course DB", "Get Syllabus"])
            elif intent == "facilities":
                plan.extend(["Search Campus DB", "Get Hostel Rules"])
            elif intent == "events":
                plan.extend(["Search Calendar DB", "Get Placement Dates"])
            elif intent == "support":
                plan.extend(["Search Contact DB", "Get Scholarship Form"])
            else:
                plan.append("Search General FAQ")
        return plan

    def run(self, state: AgentState) -> AgentState:
        print("--- 🧠 PLANNER NODE RUNNING ---")
        intents = self.detect_intents(state["user_input"])
        plan = self.create_plan(intents)
        
        state["intents"] = intents
        state["research_plan"] = plan
        return state

# ==========================================
# 3. The Executor Agent (Gathers Information)
# ==========================================
class ExecutorAgent:
    """Simulates searching a university database based on the plan."""
    def __init__(self):
        # Mock database
        self.knowledge_base = {
            "Search Course DB": "B.Tech CSE is a 4-year undergraduate program.",
            "Get Syllabus": "Syllabus includes Data Structures, OS, and AI.",
            "Search Campus DB": "Campus has 24/7 Wi-Fi and a central library.",
            "Get Hostel Rules": "Hostel curfew is 10:00 PM for all students.",
            "Search Calendar DB": "Next Hackathon is on October 15th.",
            "Get Placement Dates": "Placement drives begin in the 7th semester.",
            "Search General FAQ": "Welcome to the University Enquiry Desk."
        }

    def run(self, state: AgentState) -> AgentState:
        print("--- 🔍 EXECUTOR NODE RUNNING ---")
        gathered_data = []
        
        for task in state["research_plan"]:
            # Retrieve data if it exists in our mock DB, otherwise return a default string
            data = self.knowledge_base.get(task, f"No data found for: {task}")
            gathered_data.append(data)
            
        state["gathered_data"] = gathered_data
        return state

# ==========================================
# 4. The Generator Agent (Drafts the Final Reply)
# ==========================================
class GeneratorAgent:
    """Takes the gathered data and formats it for the user."""
    
    def run(self, state: AgentState) -> AgentState:
        print("--- ✍️ GENERATOR NODE RUNNING ---")
        
        if not state["gathered_data"]:
            state["final_response"] = "I'm sorry, I couldn't find any information on that."
            return state
            
        # Format the gathered facts into a neat bulleted list
        response = "Here is the information I found for you:\n"
        for fact in state["gathered_data"]:
            response += f"• {fact}\n"
            
        state["final_response"] = response
        return state

# ==========================================
# 5. The Graph Orchestrator (The Main Loop)
# ==========================================
def run_pipeline(user_query: str):
    # Initialize the state dictionary
    state: AgentState = {
        "user_input": user_query,
        "intents": [],
        "research_plan": [],
        "gathered_data": [],
        "final_response": ""
    }
    
    # Initialize our agents
    planner = PlannerAgent()
    executor = ExecutorAgent()
    generator = GeneratorAgent()
    
    # Pass the state sequentially through the nodes
    state = planner.run(state)
    state = executor.run(state)
    state = generator.run(state)
    
    return state

# ==========================================
# Execution Block
# ==========================================
if __name__ == "__main__":
    print("Welcome to the University Bot. Type 'exit' to quit.\n")
    
    while True:
        query = input("You: ")
        if query.lower() in ['exit', 'quit']:
            break
            
        print("\nProcessing...\n")
        
        final_state = run_pipeline(query)
        
        print("\n==========================================")
        print("BOT RESPONSE")
        print("==========================================")
        print(final_state["final_response"])
        print("\n" + "-"*42 + "\n")

Open full submission →

from abc import ABC, abstractmethod

# -----------------------------
# Base Agent
# -----------------------------
class Agent(ABC):
    @abstractmethod
        def process(self, query):
                pass


                # -----------------------------
                # Specialized Agents
                # -----------------------------
                class AdmissionAgent(Agent):
                    def process(self, query):
                            return "Admission Agent: Admission starts in June. Required documents are 10th, 12th mark sheets and ID proof."


                            class ExamAgent(Agent):
                                def process(self, query):
                                        return "Exam Agent: Semester exams begin in December. Exam timetable will be announced on the portal."


                                        class FeesAgent(Agent):
                                            def process(self, query):
                                                    return "Fees Agent: The annual tuition fee is ₹50,000. Fees can be paid online or at the accounts office."


                                                    class ScholarshipAgent(Agent):
                                                        def process(self, query):
                                                                return "Scholarship Agent: Scholarships are available based on merit and family income."


                                                                # -----------------------------
                                                                # Intent Classifier
                                                                # -----------------------------
                                                                class IntentClassifier:

                                                                    def classify(self, query):
                                                                            query = query.lower()

                                                                                    if any(word in query for word in
                                                                                                   ["admission", "admit", "apply", "eligibility"]):
                                                                                                               return "admission"

                                                                                                                       elif any(word in query for word in
                                                                                                                                        ["exam", "test", "result", "hall ticket"]):
                                                                                                                                                    return "exam"

                                                                                                                                                            elif any(word in query for word in
                                                                                                                                                                             ["fee", "fees", "payment", "tuition"]):
                                                                                                                                                                                         return "fees"

                                                                                                                                                                                                 elif any(word in query for word in
                                                                                                                                                                                                                  ["scholarship", "financial aid", "grant"]):
                                                                                                                                                                                                                              return "scholarship"

                                                                                                                                                                                                                                      else:
                                                                                                                                                                                                                                                  return "unknown"


                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  # Response Agent
                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  class ResponseAgent:

                                                                                                                                                                                                                                                      def __init__(self):
                                                                                                                                                                                                                                                              self.agents = {
                                                                                                                                                                                                                                                                          "admission": AdmissionAgent(),
                                                                                                                                                                                                                                                                                      "exam": ExamAgent(),
                                                                                                                                                                                                                                                                                                  "fees": FeesAgent(),
                                                                                                                                                                                                                                                                                                              "scholarship": ScholarshipAgent()
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                          def respond(self, intent, query):

                                                                                                                                                                                                                                                                                                                                  if intent in self.agents:
                                                                                                                                                                                                                                                                                                                                              return self.agents[intent].process(query)

                                                                                                                                                                                                                                                                                                                                                      return "Sorry, I couldn't understand your request."


                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      # Main AI Agent System
                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      class CollegeAIAgent:

                                                                                                                                                                                                                                                                                                                                                          def __init__(self):
                                                                                                                                                                                                                                                                                                                                                                  self.classifier = IntentClassifier()
                                                                                                                                                                                                                                                                                                                                                                          self.response_agent = ResponseAgent()

                                                                                                                                                                                                                                                                                                                                                                              def chat(self, query):
                                                                                                                                                                                                                                                                                                                                                                                      intent = self.classifier.classify(query)
                                                                                                                                                                                                                                                                                                                                                                                              print(f"Detected Intent: {intent}")
                                                                                                                                                                                                                                                                                                                                                                                                      response = self.response_agent.respond(intent, query)
                                                                                                                                                                                                                                                                                                                                                                                                              return response


                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              # Run Program
                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              if __name__ == "__main__":

                                                                                                                                                                                                                                                                                                                                                                                                                  bot = CollegeAIAgent()

                                                                                                                                                                                                                                                                                                                                                                                                                      print("===== College AI Agent =====")
                                                                                                                                                                                                                                                                                                                                                                                                                          print("Type 'exit' to quit.\n")

                                                                                                                                                                                                                                                                                                                                                                                                                              while True:
                                                                                                                                                                                                                                                                                                                                                                                                                                      user_input = input("You: ")

                                                                                                                                                                                                                                                                                                                                                                                                                                              if user_input.lower() == "exit":
                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Bot: Thank you!")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reply = bot.chat(user_input)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      print("Bot:", reply)

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, START, END


# -----------------------------
# State
# -----------------------------
class CollegeState(TypedDict):
    query: str
    category: str
    response: str


# -----------------------------
# Intent Analyzer
# -----------------------------
def intent_analyzer(state: CollegeState):

    query = state["query"].lower()

    academic = [
        "admission", "apply", "jee", "eligibility",
        "exam", "semester", "course", "branch",
        "department", "syllabus"
    ]

    finance = [
        "fee", "fees", "scholarship",
        "ekalyan", "payment", "hostel fee"
    ]

    campus = [
        "hostel", "library", "canteen",
        "wifi", "transport", "placement",
        "club", "sports", "lab"
    ]

    if any(word in query for word in academic):
        category = "academic"

    elif any(word in query for word in finance):
        category = "finance"

    elif any(word in query for word in campus):
        category = "campus"

    else:
        category = "general"

    return {"category": category}


# -----------------------------
# Academic Agent
# -----------------------------
def academic_agent(state: CollegeState):

    q = state["query"].lower()

    if "syllabus" in q:
        response = (
            "Course-wise syllabus is available on the official college website."
        )

    elif "exam" in q:
        response = (
            "The college follows the JUT semester system. "
            "Students should regularly check the official notice section "
            "for examination schedules and results."
        )

    elif "admission" in q or "jee" in q:
        response = (
            "Admission is based on JEE Main/JCECE counseling. "
            "Candidates must satisfy the eligibility criteria announced "
            "by the admission authority."
        )

    else:
        response = (
            "The college offers undergraduate engineering programs in "
            "Civil, Mechanical, Electrical, Electronics & Communication, "
            "and Computer Science Engineering."
        )

    return {"response": response}


# -----------------------------
# Finance Agent
# -----------------------------
def finance_agent(state: CollegeState):

    q = state["query"].lower()

    if "scholarship" in q or "ekalyan" in q:

        response = (
            "Eligible students can apply for the E-Kalyan scholarship "
            "and other government scholarship schemes."
        )

    else:

        response = (
            "Fee details are available in the official admission "
            "prospectus on the college website."
        )

    return {"response": response}


# -----------------------------
# Campus Agent
# -----------------------------
def campus_agent(state: CollegeState):

    q = state["query"].lower()

    if "placement" in q:

        response = (
            "The college has a Training and Placement Cell that organizes "
            "campus drives, training programs and placement activities."
        )

    elif "hostel" in q:

        response = (
            "Hostel facilities are available for students. "
            "Contact the college administration for availability and charges."
        )

    elif "library" in q:

        response = (
            "The college library provides academic books, journals "
            "and digital learning resources."
        )

    else:

        response = (
            "The campus provides academic infrastructure, laboratories, "
            "library and student facilities."
        )

    return {"response": response}


# -----------------------------
# General Agent
# -----------------------------
def general_agent(state: CollegeState):

    q = state["query"].lower()

    if "location" in q or "where" in q:

        response = (
            "Dumka Engineering College is located in Dumka, Jharkhand."
        )

    elif "contact" in q:

        response = (
            "Contact details are available on the official "
            "college website."
        )

    else:

        response = (
            "Please ask about admission, fees, scholarship, "
            "placements, hostel, library or academics."
        )

    return {"response": response}


# -----------------------------
# Response Formatter
# -----------------------------
def response_formatter(state: CollegeState):

    print("\n" + "=" * 60)
    print("DEC AI ASSISTANT")
    print("=" * 60)

    print(f"\nCategory : {state['category'].title()}")

    print("\nAnswer :")
    print(state["response"])

    return state


# -----------------------------
# Router
# -----------------------------
def router(state: CollegeState):
    return state["category"]


# -----------------------------
# Build Graph
# -----------------------------
workflow = StateGraph(CollegeState)

workflow.add_node("Intent Analyzer", intent_analyzer)
workflow.add_node("Academic Agent", academic_agent)
workflow.add_node("Finance Agent", finance_agent)
workflow.add_node("Campus Agent", campus_agent)
workflow.add_node("General Agent", general_agent)
workflow.add_node("Formatter", response_formatter)

workflow.add_edge(START, "Intent Analyzer")

workflow.add_conditional_edges(
    "Intent Analyzer",
    router,
    {
        "academic": "Academic Agent",
        "finance": "Finance Agent",
        "campus": "Campus Agent",
        "general": "General Agent",
    },
)

workflow.add_edge("Academic Agent", "Formatter")
workflow.add_edge("Finance Agent", "Formatter")
workflow.add_edge("Campus Agent", "Formatter")
workflow.add_edge("General Agent", "Formatter")

workflow.add_edge("Formatter", END)

app = workflow.compile()


# -----------------------------
# Main Program
# -----------------------------
print("=" * 60)
print("🎓 Dumka Engineering College AI Assistant")
print("Type 'exit' to quit.")
print("=" * 60)

while True:

    query = input("\nYou : ")

    if query.lower() == "exit":
        print("\nThank you!")
        break

    app.invoke(
        {
            "query": query,
            "category": "",
            "response": "",
        }
    )

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, START, END


class DEC(TypedDict):
    query: str
    intent: str
    response: str


def classifier(state: DEC):
    q = state["query"].lower()

    if any(w in q for w in ("fee", "fees", "cost")):
        intent = "fees"
    elif any(w in q for w in ("exam", "semester", "timetable", "result")):
        intent = "exam"
    elif any(w in q for w in ("admission", "admit", "apply", "eligibility", "cutoff", "jee")):
        intent = "admission"
    elif any(w in q for w in ("scholarship", "ekalyan", "financial")):
        intent = "scholarship"
    else:
        intent = "unknown"

    return {"intent": intent}


def fees_agent(state: DEC):
    return {
        "response": (
            "DEC fees are Rs 66,425-66,600 per year depending on branch. "
            "Total B.Tech fee ranges from Rs 2.6L to Rs 2.65L. "
            "SC/ST/OBC students can get 100% waiver via E-Kalyan."
        )
    }


def exam_agent(state: DEC):
    return {
        "response": (
            "DEC follows the JUT semester system. Exams are held twice a year "
            "(mid-sem and end-sem). Exam fee is Rs 2,000 per semester. "
            "Results are posted on the college website and notice board."
        )
    }


def admission_agent(state: DEC):
    return {
        "response": (
            "Admission is through JEE Main or JCECE. Min 45% in 10+2 (PCM) required. "
            "Application runs May-June. CSE cutoff is ~50-60 percentile, "
            "ECE ~45-55, EEE/MECH ~40-50, Civil ~35-45."
        )
    }


def scholarship_agent(state: DEC):
    return {
        "response": (
            "DEC students can apply for E-Kalyan scholarship (100% fee waiver for "
            "SC/ST/OBC). Other merit-based scholarships are available. "
            "Apply before the deadline with all required documents."
        )
    }


def unknown_agent(state: DEC):
    return {
        "response": "I couldn't understand. Try asking about fees, exams, admission, or scholarship."
    }


def response_agent(state: DEC):
    print("\n" + "="*50)
    print(f"[{state['intent'].upper()}]")
    print("="*50)
    print(state.get("response", ""))
    return state


def route(state: DEC):
    return state["intent"]


workflow = StateGraph(DEC)

workflow.add_node("Classifier", classifier)
workflow.add_node("Fees", fees_agent)
workflow.add_node("Exam", exam_agent)
workflow.add_node("Admission", admission_agent)
workflow.add_node("Scholarship", scholarship_agent)
workflow.add_node("Unknown", unknown_agent)
workflow.add_node("Response", response_agent)

workflow.add_edge(START, "Classifier")

workflow.add_conditional_edges(
    "Classifier",
    route,
    {
        "fees": "Fees",
        "exam": "Exam",
        "admission": "Admission",
        "scholarship": "Scholarship",
        "unknown": "Unknown",
    },
)

for agent in ("Fees", "Exam", "Admission", "Scholarship", "Unknown"):
    workflow.add_edge(agent, "Response")

workflow.add_edge("Response", END)

app = workflow.compile()


print("===== Dumka Engineering College Assistant =====")
query = input("Enter your question: ")

result = app.invoke({
    "query": query,
    "intent": "",
    "response": "",
})

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, START, END


class DECState(TypedDict):
    query: str
    category: str
    department: str
    response: str
    follow_up: str


BRANCHES = {
    "cse": "CSE",
    "mech": "MECH",
    "civil": "CIVIL",
    "eee": "EEE",
    "ece": "ECE",
}


def classify_query(state: DECState):
    q = state["query"].lower()
    
    if any(w in q for w in ("fee", "fees", "cost", "payment", "scholarship", "financial")):
        category = "fees"
    elif any(w in q for w in ("admission", "admit", "apply", "eligibility", "cutoff", "jee")):
        category = "admission"
    elif any(w in q for w in ("placement", "recruiter", "job", "package", "salary", "median")):
        category = "placement"
    elif any(w in q for w in ("hostel", "mess", "accommodation", "dorm")):
        category = "hostel"
    elif any(w in q for w in ("library", "book", "lab", "laboratory", "facility")):
        category = "infrastructure"
    elif any(w in q for w in ("exam", "semester", "timetable", "result")):
        category = "exams"
    else:
        category = "general"

    department = "general"
    for code, name in BRANCHES.items():
        if code in q or name.lower() in q:
            department = name
            break

    return {"category": category, "department": department}


def extract_department(state: DECState):
    follow_up = ""
    if state["category"] == "general" and state["department"] == "general":
        follow_up = (
            "I can help with fees, admissions, placements, hostel, "
            "infrastructure, or exams. Try asking about B.Tech CSE fees "
            "or JEE cutoff for Mechanical."
        )
    return {"follow_up": follow_up}


def fees_agent(state: DECState):
    dep = state["department"]
    fee_map = {
        "CSE": "Rs 2,65,700 total (Rs 66,425/year)",
        "ECE": "Rs 2,65,700 total (Rs 66,425/year)",
        "EEE": "Rs 2,60,000 total (Rs 65,000/year)",
        "MECH": "Rs 2,60,000 total (Rs 65,000/year)",
        "CIVIL": "Rs 2,60,000 total (Rs 65,000/year)",
    }

    base = (
        "Dumka Engineering College fees range from Rs 66,425 to Rs 66,600 per year "
        "depending on the branch. SC/ST/OBC students can get 100% fee waiver "
        "through the E-Kalyan scholarship."
    )
    if dep in fee_map:
        base += f"\n\nFor {dep}: {fee_map[dep]}."
    return {"response": base}


def admission_agent(state: DECState):
    dep = state["department"]
    base = (
        "Admission to DEC is through JEE Main or JCECE (Jharkhand Combined Entrance). "
        "You need at least 45% in 10+2 (PCM) for General category. "
        "The application process usually runs from May to June each year."
    )

    cutoff = {
        "CSE": "around 50-60 percentile in JEE Main",
        "ECE": "around 45-55 percentile",
        "EEE": "around 40-50 percentile",
        "MECH": "around 40-50 percentile",
        "CIVIL": "around 35-45 percentile",
    }

    if dep in cutoff:
        base += f"\n\nFor {dep}, the typical cutoff is {cutoff[dep]}."
    return {"response": base}


def placement_agent(state: DECState):
    dep = state["department"]
    base = (
        "DEC has a median placement package of Rs 3.75 LPA. "
        "Top recruiters include CINIF Technologies and other IT/engineering firms. "
        "The Training & Placement cell actively prepares students with mock interviews "
        "and soft skills training."
    )

    dep_placement = {
        "CSE": "\nCSE students have the highest placement rate, with some offers up to Rs 6-8 LPA.",
        "ECE": "\nECE graduates are recruited in core electronics firms and IT companies.",
        "MECH": "\nMechanical students get opportunities in manufacturing and automotive sectors.",
        "EEE": "\nEEE students are placed in power sector companies and core electrical firms.",
        "CIVIL": "\nCivil graduates work with construction firms and government infrastructure projects.",
    }

    if dep in dep_placement:
        base += dep_placement[dep]
    return {"response": base}


def hostel_agent(state: DECState):
    return {
        "response": (
            "DEC provides separate hostels for boys and girls on campus. "
            "Hostel fee is approximately Rs 21,000 per year. "
            "Mess fee is around Rs 3,000 per month. "
            "Rooms are available on a sharing basis with basic furniture and 24/7 electricity."
        )
    }


def infrastructure_agent(state: DECState):
    return {
        "response": (
            "DEC has a well-stocked library with technical journals and reference books. "
            "The campus has dedicated labs for each department - CSE lab, ECE lab, "
            "Mechanical workshop, Civil surveying lab, and Electrical machines lab. "
            "Wi-Fi is available across campus. The college also has a sports ground "
            "and an annual cultural fest."
        )
    }


def exams_agent(state: DECState):
    return {
        "response": (
            "DEC follows the semester system under Jharkhand University of Technology (JUT), Ranchi. "
            "Exams are held twice a year - mid-semester and end-semester. "
            "Exam fee is Rs 2,000 per semester. "
            "Results are published on the college website and notice board."
        )
    }


def general_agent(state: DECState):
    return {
        "response": (
            "Dumka Engineering College, established in 2013, is located in Dumka, "
            "the second capital of Jharkhand. It offers B.Tech in 5 branches - "
            "Computer Science, Electronics & Communication, Electrical, Mechanical, "
            "and Civil Engineering. The college also offers BCA. "
            "It is affiliated with Jharkhand University of Technology and approved by AICTE."
        )
    }


def format_response(state: DECState):
    header = f"[{state['category'].upper()}]"
    if state.get("department", "general") != "general":
        header += f" - {state['department']}"

    lines = [f"\n{'='*50}", header, f"{'='*50}"]
    lines.append(state.get("response", ""))
    
    follow_up = state.get("follow_up", "")
    if follow_up:
        lines.append(f"\n-> {follow_up}")

    return {"response": "\n".join(lines)}


def route_category(state: DECState):
    return state["category"]


workflow = StateGraph(DECState)

workflow.add_node("Classifier", classify_query)
workflow.add_node("Extract Dept", extract_department)
workflow.add_node("Fees", fees_agent)
workflow.add_node("Admission", admission_agent)
workflow.add_node("Placement", placement_agent)
workflow.add_node("Hostel", hostel_agent)
workflow.add_node("Infrastructure", infrastructure_agent)
workflow.add_node("Exams", exams_agent)
workflow.add_node("General", general_agent)
workflow.add_node("Formatter", format_response)

workflow.add_edge(START, "Classifier")
workflow.add_edge("Classifier", "Extract Dept")

workflow.add_conditional_edges(
    "Extract Dept",
    route_category,
    {
        "fees": "Fees",
        "admission": "Admission",
        "placement": "Placement",
        "hostel": "Hostel",
        "infrastructure": "Infrastructure",
        "exams": "Exams",
        "general": "General",
    },
)

for agent in ("Fees", "Admission", "Placement", "Hostel", "Infrastructure", "Exams", "General"):
    workflow.add_edge(agent, "Formatter")

workflow.add_edge("Formatter", END)
app = workflow.compile()


def interactive():
    print("===== Dumka Engineering College Assistant =====")
    print("Ask about: fees, admission, placements, hostel, labs, exams, or anything about DEC.")
    print("Type 'exit' to quit.\n")

    while True:
        query = input("You: ").strip()
        if query.lower() in ("exit", "quit"):
            break
        if not query:
            continue

        result = app.invoke({
            "query": query,
            "category": "",
            "department": "",
            "response": "",
            "follow_up": "",
        })

        print(result.get("response", ""))
        print()


if __name__ == "__main__":
    interactive()

Open full submission →

# Wrifrom abc import ABC, abstractmethod

# -----------------------------
# Base Agent
# -----------------------------
class Agent(ABC):
    @abstractmethod
        def process(self, query):
                pass
                
                
                # -----------------------------
                # Specialized Agents
                # -----------------------------
                class AdmissionAgent(Agent):
                    def process(self, query):
                            return "Admission Agent: Admission starts in June. Required documents are 10th, 12th mark sheets and ID proof."
                            
                            
                            class ExamAgent(Agent):
                                def process(self, query):
                                        return "Exam Agent: Semester exams begin in December. Exam timetable will be announced on the portal."
                                        
                                        
                                        class FeesAgent(Agent):
                                            def process(self, query):
                                                    return "Fees Agent: The annual tuition fee is ₹50,000. Fees can be paid online or at the accounts office."
                                                    
                                                    
                                                    class ScholarshipAgent(Agent):
                                                        def process(self, query):
                                                                return "Scholarship Agent: Scholarships are available based on merit and family income."
                                                                
                                                                
                                                                # -----------------------------
                                                                # Intent Classifier
                                                                # -----------------------------
                                                                class IntentClassifier:
                                                                
                                                                    def classify(self, query):
                                                                            query = query.lower()
                                                                            
                                                                                    if any(word in query for word in
                                                                                                   ["admission", "admit", "apply", "eligibility"]):
                                                                                                               return "admission"
                                                                                                               
                                                                                                                       elif any(word in query for word in
                                                                                                                                        ["exam", "test", "result", "hall ticket"]):
                                                                                                                                                    return "exam"
                                                                                                                                                    
                                                                                                                                                            elif any(word in query for word in
                                                                                                                                                                             ["fee", "fees", "payment", "tuition"]):
                                                                                                                                                                                         return "fees"
                                                                                                                                                                                         
                                                                                                                                                                                                 elif any(word in query for word in
                                                                                                                                                                                                                  ["scholarship", "financial aid", "grant"]):
                                                                                                                                                                                                                              return "scholarship"
                                                                                                                                                                                                                              
                                                                                                                                                                                                                                      else:
                                                                                                                                                                                                                                                  return "unknown"
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  # Response Agent
                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  class ResponseAgent:
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                      def __init__(self):
                                                                                                                                                                                                                                                              self.agents = {
                                                                                                                                                                                                                                                                          "admission": AdmissionAgent(),
                                                                                                                                                                                                                                                                                      "exam": ExamAgent(),
                                                                                                                                                                                                                                                                                                  "fees": FeesAgent(),
                                                                                                                                                                                                                                                                                                              "scholarship": ScholarshipAgent()
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                          def respond(self, intent, query):
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                  if intent in self.agents:
                                                                                                                                                                                                                                                                                                                                              return self.agents[intent].process(query)
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                      return "Sorry, I couldn't understand your request."
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      # Main AI Agent System
                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      class CollegeAIAgent:
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                          def __init__(self):
                                                                                                                                                                                                                                                                                                                                                                  self.classifier = IntentClassifier()
                                                                                                                                                                                                                                                                                                                                                                          self.response_agent = ResponseAgent()
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                              def chat(self, query):
                                                                                                                                                                                                                                                                                                                                                                                      intent = self.classifier.classify(query)
                                                                                                                                                                                                                                                                                                                                                                                              print(f"Detected Intent: {intent}")
                                                                                                                                                                                                                                                                                                                                                                                                      response = self.response_agent.respond(intent, query)
                                                                                                                                                                                                                                                                                                                                                                                                              return response
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              # Run Program
                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              if __name__ == "__main__":
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                  bot = CollegeAIAgent()
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                      print("===== College AI Agent =====")
                                                                                                                                                                                                                                                                                                                                                                                                                          print("Type 'exit' to quit.\n")
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                              while True:
                                                                                                                                                                                                                                                                                                                                                                                                                                      user_input = input("You: ")
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                              if user_input.lower() == "exit":
                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Bot: Thank you!")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      break
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reply = bot.chat(user_input)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      print("Bot:", reply)te your Python code here
print("Hello, Excelrs!")

Open full submission →

# Write your Python code here

from abc import ABC, abstractmethod

# -----------------------------
# Base Agent
# -----------------------------
class Agent(ABC):
    @abstractmethod
        def process(self, query):
                pass


                # -----------------------------
                # Specialized Agents
                # -----------------------------
                class AdmissionAgent(Agent):
                    def process(self, query):
                            return "Admission Agent: Admission starts in June. Required documents are 10th, 12th mark sheets and ID proof."


                            class ExamAgent(Agent):
                                def process(self, query):
                                        return "Exam Agent: Semester exams begin in December. Exam timetable will be announced on the portal."


                                        class FeesAgent(Agent):
                                            def process(self, query):
                                                    return "Fees Agent: The annual tuition fee is ₹50,000. Fees can be paid online or at the accounts office."


                                                    class ScholarshipAgent(Agent):
                                                        def process(self, query):
                                                                return "Scholarship Agent: Scholarships are available based on merit and family income."


                                                                # -----------------------------
                                                                # Intent Classifier
                                                                # -----------------------------
                                                                class IntentClassifier:

                                                                    def classify(self, query):
                                                                            query = query.lower()

                                                                                    if any(word in query for word in
                                                                                                   ["admission", "admit", "apply", "eligibility"]):
                                                                                                               return "admission"

                                                                                                                       elif any(word in query for word in
                                                                                                                                        ["exam", "test", "result", "hall ticket"]):
                                                                                                                                                    return "exam"

                                                                                                                                                            elif any(word in query for word in
                                                                                                                                                                             ["fee", "fees", "payment", "tuition"]):
                                                                                                                                                                                         return "fees"

                                                                                                                                                                                                 elif any(word in query for word in
                                                                                                                                                                                                                  ["scholarship", "financial aid", "grant"]):
                                                                                                                                                                                                                              return "scholarship"

                                                                                                                                                                                                                                      else:
                                                                                                                                                                                                                                                  return "unknown"


                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  # Response Agent
                                                                                                                                                                                                                                                  # -----------------------------
                                                                                                                                                                                                                                                  class ResponseAgent:

                                                                                                                                                                                                                                                      def __init__(self):
                                                                                                                                                                                                                                                              self.agents = {
                                                                                                                                                                                                                                                                          "admission": AdmissionAgent(),
                                                                                                                                                                                                                                                                                      "exam": ExamAgent(),
                                                                                                                                                                                                                                                                                                  "fees": FeesAgent(),
                                                                                                                                                                                                                                                                                                              "scholarship": ScholarshipAgent()
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                          def respond(self, intent, query):

                                                                                                                                                                                                                                                                                                                                  if intent in self.agents:
                                                                                                                                                                                                                                                                                                                                              return self.agents[intent].process(query)

                                                                                                                                                                                                                                                                                                                                                      return "Sorry, I couldn't understand your request."


                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      # Main AI Agent System
                                                                                                                                                                                                                                                                                                                                                      # -----------------------------
                                                                                                                                                                                                                                                                                                                                                      class CollegeAIAgent:

                                                                                                                                                                                                                                                                                                                                                          def __init__(self):
                                                                                                                                                                                                                                                                                                                                                                  self.classifier = IntentClassifier()
                                                                                                                                                                                                                                                                                                                                                                          self.response_agent = ResponseAgent()

                                                                                                                                                                                                                                                                                                                                                                              def chat(self, query):
                                                                                                                                                                                                                                                                                                                                                                                      intent = self.classifier.classify(query)
                                                                                                                                                                                                                                                                                                                                                                                              print(f"Detected Intent: {intent}")
                                                                                                                                                                                                                                                                                                                                                                                                      response = self.response_agent.respond(intent, query)
                                                                                                                                                                                                                                                                                                                                                                                                              return response


                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              # Run Program
                                                                                                                                                                                                                                                                                                                                                                                                              # -----------------------------
                                                                                                                                                                                                                                                                                                                                                                                                              if __name__ == "__main__":

                                                                                                                                                                                                                                                                                                                                                                                                                  bot = CollegeAIAgent()

                                                                                                                                                                                                                                                                                                                                                                                                                      print("===== College AI Agent =====")
                                                                                                                                                                                                                                                                                                                                                                                                                          print("Type 'exit' to quit.\n")

                                                                                                                                                                                                                                                                                                                                                                                                                              while True:
                                                                                                                                                                                                                                                                                                                                                                                                                                      user_input = input("You: ")

                                                                                                                                                                                                                                                                                                                                                                                                                                              if user_input.lower() == "exit":
                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Bot: Thank you!")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reply = bot.chat(user_input)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      print("Bot:", reply)

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END

class StudentState(TypedDict):
    query: str
    intent: str
    response: str

def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state

def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. Students should submit the application form with all required documents."
    )
    return state

def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state

def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state

def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state

def unknown_agent(state: StudentState):
    state["response"] = (
        "Sorry! I couldn't understand your question. Please ask about admission, exam, fees, or scholarship."
    )
    return state

def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state

def route(state: StudentState):
    return state["intent"]

workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Unknown Agent", unknown_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
        "unknown": "Unknown Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")
workflow.add_edge("Unknown Agent", "Response Agent")
workflow.add_edge("Response Agent", END)

app = workflow.compile()

print("===== College Student Assistant =====")

query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": "",
    }
)

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END

class StudentState(TypedDict):
    query: str
        intent: str
            response: str

            def intent_classifier(state: StudentState):
                question = state["query"].lower()

                    if "admission" in question:
                            state["intent"] = "admission"
                                elif "exam" in question:
                                        state["intent"] = "exam"
                                            elif "fee" in question or "fees" in question:
                                                    state["intent"] = "fees"
                                                        elif "scholarship" in question:
                                                                state["intent"] = "scholarship"
                                                                    else:
                                                                            state["intent"] = "unknown"

                                                                               return state

                                                                                def admission_agent(state: StudentState):
                                                                                    state["response"] = (
                                                                                            "Admission process starts in June. "
                                                                                                    "Students should submit the application form with all required documents."
                                                                                                        )
                                                                                                            return state

                                                                                                            def exam_agent(state: StudentState):
                                                                                                                state["response"] = (
                                                                                                                        "The examination timetable is available on the college portal."
                                                                                                                            )
                                                                                                                                return state

                                                                                                                                def fees_agent(state: StudentState):
                                                                                                                                    state["response"] = (
                                                                                                                                            "Students can pay their fees online through the student portal or at the accounts office."
                                                                                                                                                )
                                                                                                                                                    return state

                                                                                                                                                    def scholarship_agent(state: StudentState):
                                                                                                                                                        state["response"] = (
                                                                                                                                                                "Eligible students can apply for scholarships before the last date by submitting all required documents."
                                                                                                                                                                    )
                                                                                                                                                                        return state

                                                                                                                                                                        def response_agent(state: StudentState):
                                                                                                                                                                            print("\n-----------------------------")
                                                                                                                                                                                print("Final Response")
                                                                                                                                                                                    print("-----------------------------")
                                                                                                                                                                                        print(state["response"])
                                                                                                                                                                                            return state

                                                                                                                                                                                            def route(state: StudentState):
                                                                                                                                                                                                return state["intent"]

                                                                                                                                                                                                workflow = StateGraph(StudentState)

                                                                                                                                                                                                workflow.add_node("Intent Classifier", intent_classifier)
                                                                                                                                                                                                workflow.add_node("Admission Agent", admission_agent)
                                                                                                                                                                                                workflow.add_node("Exam Agent", exam_agent)
                                                                                                                                                                                                workflow.add_node("Fees Agent", fees_agent)
                                                                                                                                                                                                workflow.add_node("Scholarship Agent", scholarship_agent)
                                                                                                                                                                                                workflow.add_node("Response Agent", response_agent)

                                                                                                                                                                                                workflow.set_entry_point("Intent Classifier")

                                                                                                                                                                                                workflow.add_conditional_edges(
                                                                                                                                                                                                    "Intent Classifier",
                                                                                                                                                                                                        route,
                                                                                                                                                                                                            {
                                                                                                                                                                                                                    "admission": "Admission Agent",
                                                                                                                                                                                                                            "exam": "Exam Agent",
                                                                                                                                                                                                                                    "fees": "Fees Agent",
                                                                                                                                                                                                                                            "scholarship": "Scholarship Agent",
                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                workflow.add_edge("Admission Agent", "Response Agent")
                                                                                                                                                                                                                                                workflow.add_edge("Exam Agent", "Response Agent")
                                                                                                                                                                                                                                                workflow.add_edge("Fees Agent", "Response Agent")
                                                                                                                                                                                                                                                workflow.add_edge("Scholarship Agent", "Response Agent")

                                                                                                                                                                                                                                                workflow.add_edge("Response Agent", END)

                                                                                                                                                                                                                                                app = workflow.compile()

                                                                                                                                                                                                                                                print("===== College Student Assistant =====")
                                                                                                                                                                                                                                                query = input("Enter your question: ")

                                                                                                                                                                                                                                                app.invoke(
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                            "query": query,
                                                                                                                                                                                                                                                                    "intent": "",
                                                                                                                                                                                                                                                                            "response": ""
                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                )

Open full submission →

https://collegeaiassistant-2jyc7w5rfln2a6yurl5k2b.streamlit.app/

Open full submission →

Open full submission →

# AI Admission Assistant
# Multi-Agent System


class AdmissionAgent:
    def process(self, query):
        return """
Admission Information:
• Eligibility: 10+2 with PCM
• Required Documents:
  - Aadhaar Card
  - 10th Marksheet
  - 12th Marksheet
  - Passport Photo
  - Income certificate
• Admission is based on JEE Main Rank.
• For lateral entry 2nd year admission- Diploma Marksheet

"""


class ExamAgent:
    def process(self, query):
        return """
Exam Information:
• Entrance Exam: JEE Main
• Entrance Exam: WBJEE 
• Admit Card available before exam
• Carry Admit Card and Valid ID Proof.

"""


class FeesAgent:
    def process(self, query):
        return """
Fee Information:
• Tuition Fee: ₹75,000 per year
• Hostel Fee: ₹30,000 per year
• Payment Mode:
  - Online
  - Bank Challan
"""


class ScholarshipAgent:
    def process(self, query):
        return """
Scholarship Information:
• Merit Scholarship
• SC/ST Scholarship
• EWS Scholarship
• NSP Scholarship Available
"""


# Response Agent

class ResponseAgent:

    def generate(self, response):
        return f"""

 AI Admission Assistant Response


{response}


Thank You!

"""


# ----------------------------
# Intent Classifier
# ----------------------------

class IntentClassifier:

    def classify(self, query):

        query = query.lower()

        if "admission" in query or "document" in query or "eligibility" in query:
            return "admission"

        elif "exam" in query or "admit" in query or "date" in query:
            return "exam"

        elif "fee" in query or "fees" in query or "payment" in query:
            return "fees"

        elif "scholarship" in query or "financial" in query:
            return "scholarship"

        else:
            return "unknown"



# Main AI System


class AIAdmissionAssistant:

    def __init__(self):

        self.classifier = IntentClassifier()

        self.admission = AdmissionAgent()

        self.exam = ExamAgent()

        self.fees = FeesAgent()

        self.scholarship = ScholarshipAgent()

        self.response = ResponseAgent()

    def ask(self, query):

        intent = self.classifier.classify(query)

        if intent == "admission":
            result = self.admission.process(query)

        elif intent == "exam":
            result = self.exam.process(query)

        elif intent == "fees":
            result = self.fees.process(query)

        elif intent == "scholarship":
            result = self.scholarship.process(query)

        else:
            result = "Sorry! I couldn't understand your question."

        print(self.response.generate(result))



# Run program


assistant = AIAdmissionAssistant()

while True:

    print("\n===== AI Admission Assistant =====")
    query = input("Ask your Question (type exit to quit): ")

    if query.lower() == "exit":
        print("Goodbye!")
        break

    assistant.ask(query)

Open full submission →

from abc import ABC , abstractmethod
class Agent(ABC):
  @abstractmethod
  def process(self,query):
 pass
     class AdmissionAgent(Agent):
 def process(self,query):
 return "Admission Agent: Admission starts in june. Required documents are 10th,12th mark sheet and ID proof"
     class ExamAgent(Agent):
  def process(self,query):
  return "Exam Agent: semster exam begin in December.Exam timetable will be notify soon on the portal"
     class FeesAgent(self,query):
   def process(self,query):
return "Fess Agent: the annual tuition fee is rs 50.000.Fess can be the account office"
    class ScholarshipAgent(self,query):
  def process(self,query):
return "Scholarship Agent: scholarship are avaiable based on merit and family income"
    class Intentclassifier:
 def classify(self,query):
  query = query.lower()
  if any(word in query for word in ["admission","admit","apply","eligibility"]):
  return "admission"
      elif any(word in query for word in["exam","test","result","hallticket"]):
  return "exam"
      elif any(word in query for word in["fee","fees","payment","tuition"]):
  return "fees"
    elif any(word in query for word in["scholarship","financial","grant"]):
 return "scholarship"
  else:
  return "unknown"
    class ResponseAgent:
   def __init__(self):
  self.agents = {
   "admission": AdmissionAgent(),"exam": ExamAgent(),"fees": FeesAgent(), "scholarship": ScholarshipAgent()
   }
    def respond(self,intent,query):
       if intent in self.agent:
 return self.agents[intent].process(query)
 return "sorry,i could't understand your request."
  class collegeAIAgent:
    def __init__(self):
self.classifier = Intentclassifier()
self.response_agent = ResponseAgent()
 
    def chat(self,query):
  intent = self.classifier.classify(query)
  print( f "Detectedb Intent :{Intent}")
  response = self.response_agent.respond(intent,query)
  return response
      if ___name___ == "__main__";
  bot = collegeAIAgent()
  print("===college AI Agent===")
  print ("type 'exit' to quit.\n")
    while true:
    user_input = input("you:")
    if user_input.lower() == "exit":
  print("Bot:thank you!")
      break
      reply = bot.chat(user_input)
  print("Bot:",reply)

Open full submission →

import random

class AdmissionAgent:
    def reply(self):
        return (
            "🎓 Admission Agent\n"
            "Admission Process (Step by Step):\n"
            "1. First, fill out the online application form.\n"
            "   👉 Here you enter your personal details and academic records.\n"
            "2. Next, upload the required documents.\n"
            "   📄 For example: 10th/12th marksheet, ID proof, and passport size photo.\n"
            "3. Pay the registration fee.\n"
            "   💳 Payment can be done online (UPI, Netbanking, Card).\n"
            "4. Once everything is complete, you will receive a confirmation email.\n"
            "   📧 This email contains your application number and further instructions.\n\n"
            "✨ Tip: Fill in the details carefully, even a small mistake can cause rejection!"
        )


class ExamAgent:
    def reply(self):
        return (
            "📝 Exam Agent\n"
            "Semester exams start from 10 December.\n"
            "Admit card will be available 5 days before the exam."
        )


class FeesAgent:
    def reply(self):
        return (
            "💰 Fees Agent\n"
            "B.Tech First Year Fees:\n"
            "• Tuition Fee : ₹73,000\n"
            "• Hostel Fee  : ₹20000\n"
            "• Registration: ₹5,000"
        )


class ScholarshipAgent:
    def reply(self):
        return (
            "🎓 Scholarship Agent\n"
            "Available Scholarships:\n"
            "- Merit Scholarship\n"
            "- SC/ST Scholarship\n"
            "- OBC Scholarship"
            
        )


class IntentClassifier:
    def detect(self, text):
        text = text.lower().strip()

        if "admission" in text:
            return "admission"
        elif "exam" in text:
            return "exam"
        elif "fee" in text or "fees" in text:
            return "fees"
        elif "scholarship" in text:
            return "scholarship"
        elif text in ["bye", "exit", "quit"]:
            return "exit"
        elif "help" in text:
            return "help"
        else:
            return "unknown"


class ResponseAgent:
    def respond(self, intent):
        if intent == "admission":
            return AdmissionAgent().reply()
        elif intent == "exam":
            return ExamAgent().reply()
        elif intent == "fees":
            return FeesAgent().reply()
        elif intent == "scholarship":
            return ScholarshipAgent().reply()
        elif intent == "help":
            return (
                "📌 I can help with:\n"
                "- Admission\n"
                "- Exam\n"
                "- Fees\n"
                "- Scholarship\n"
                "Type 'bye' to exit."
            )
        elif intent == "exit":
            exit_messages = [
                "👋 Thank you! Have a nice day.",
                "🚪 Session closed. Goodbye!",
                "✨ Bye! Wishing you success.",
                "🌸 Take care, see you soon!"
            ]
            return random.choice(exit_messages)
        else:
            return (
                "🤖 Sorry! I can help only with:\n"
                "- Admission\n"
                "- Exam\n"
                "- Fees\n"
                "- Scholarship\n"
                "Type 'help' to see options."
            )


def main():
    print("=" * 50)
    print("🎓 UNIVERSITY AI MULTI-AGENT SYSTEM")
    print("=" * 50)

    name = input("\n👋 Hello! What's your name? ")
    print(f"\nWelcome {name}! Ask about Admission, Exam, Fees or Scholarship.")
    print("Type 'help' for options or 'bye' to exit.\n")

    classifier = IntentClassifier()
    response = ResponseAgent()

    while True:
        user = input("You : ")
        intent = classifier.detect(user)

        print("\nBot :")
        print(response.respond(intent))
        print()

        if intent == "exit":
            break


if __name__ == "__main__":
    main()

Open full submission →

# Write your Python code here
print("Hello, Excelrs!")

Open full submission →

from typing import TypedDict
from langgraph.graph import StateGraph, END

class StudentState(TypedDict):
    query: str
    intent: str
    response: str

def intent_classifier(state: StudentState):
    question = state["query"].lower()

    if "admission" in question:
        state["intent"] = "admission"
    elif "exam" in question:
        state["intent"] = "exam"
    elif "fee" in question or "fees" in question:
        state["intent"] = "fees"
    elif "scholarship" in question:
        state["intent"] = "scholarship"
    else:
        state["intent"] = "unknown"

    return state


# Admission Agent

def admission_agent(state: StudentState):
    state["response"] = (
        "Admission process starts in June. "
        "Students should submit the application form with all required documents."
    )
    return state
# Exam Agent
def exam_agent(state: StudentState):
    state["response"] = (
        "The examination timetable is available on the college portal."
    )
    return state


# Fees Agent

def fees_agent(state: StudentState):
    state["response"] = (
        "Students can pay their fees online through the student portal or at the accounts office."
    )
    return state


# Scholarship Agent

def scholarship_agent(state: StudentState):
    state["response"] = (
        "Eligible students can apply for scholarships before the last date by submitting all required documents."
    )
    return state


# Response Agent

def response_agent(state: StudentState):
    print("\n-----------------------------")
    print("Final Response")
    print("-----------------------------")
    print(state["response"])
    return state


# Routing Function

def route(state: StudentState):
    return state["intent"]


# Create Graph

workflow = StateGraph(StudentState)

workflow.add_node("Intent Classifier", intent_classifier)
workflow.add_node("Admission Agent", admission_agent)
workflow.add_node("Exam Agent", exam_agent)
workflow.add_node("Fees Agent", fees_agent)
workflow.add_node("Scholarship Agent", scholarship_agent)
workflow.add_node("Response Agent", response_agent)

workflow.set_entry_point("Intent Classifier")

workflow.add_conditional_edges(
    "Intent Classifier",
    route,
    {
        "admission": "Admission Agent",
        "exam": "Exam Agent",
        "fees": "Fees Agent",
        "scholarship": "Scholarship Agent",
    },
)

workflow.add_edge("Admission Agent", "Response Agent")
workflow.add_edge("Exam Agent", "Response Agent")
workflow.add_edge("Fees Agent", "Response Agent")
workflow.add_edge("Scholarship Agent", "Response Agent")

workflow.add_edge("Response Agent", END)

app = workflow.compile()

# Run Program

print("===== College Student Assistant =====")
query = input("Enter your question: ")

app.invoke(
    {
        "query": query,
        "intent": "",
        "response": ""
    }
)

Open full submission →

# Write your Python code here
print("hello world")

Open full submission →