Candilyzer: Candidate Analyzer

from agno.agent import Agent
from agno.models.nebius import Nebius
from agno.tools.github import GithubTools
from agno.tools.exa import ExaTools
from agno.tools.thinking import ThinkingTools
from agno.tools.reasoning import ReasoningTools

# Multi-Candidate Analyzer Agent
agent = Agent(
    description="Strict candidate evaluator for technical hiring",
    instructions="""
        Evaluate GitHub candidates with zero assumptions:
        1. Analyze code quality, commit frequency, and project structure
        2. Assess skills shown through actual repositories
        3. Match with required job role skills
        4. Provide strict scoring (0-100) with justification
        5. No fluff - only data-backed assessments
    """,
    model=Nebius(
        id="deepseek-ai/DeepSeek-R1",
        api_key=api_key
    ),
    name="StrictCandidateEvaluator",
    tools=[
        ThinkingTools(
            think=True,
            instructions="Strict GitHub candidate evaluation"
        ),
        GithubTools(access_token=github_api_key),
        ExaTools(
            api_key=exa_api_key,
            include_domains=["github.com"],
            type="keyword"
        ),
        ReasoningTools(add_instructions=True)
    ],
    markdown=True,
    show_tool_calls=True
)

ThinkingTools(
    think=True,  # Agent thinks through evaluation strategy first
    instructions="Strict GitHub candidate evaluation"
)

GithubTools(access_token=github_api_key)

# Agent can:
# - Fetch user repositories
# - Analyze commit history
# - Review code quality
# - Check contribution patterns
# - Examine project complexity

ExaTools(
    api_key=exa_api_key,
    include_domains=["linkedin.com", "github.com"],
    type="keyword",
    text_length_limit=2000,
    show_results=True
)

# Extracts:
# - Job titles and descriptions
# - Professional experience
# - Skills and endorsements
# - Career progression

ReasoningTools(add_instructions=True)

# Provides:
# - Step-by-step reasoning
# - Evidence-based conclusions
# - Clear justifications for scores
# - Transparent evaluation process

evaluation_criteria = """
    GitHub Analysis:
    - Repository quality and structure (20 points)
    - Commit frequency and consistency (15 points)
    - Code complexity and patterns (20 points)
    - Technology stack relevance (15 points)
    
    LinkedIn Analysis:
    - Relevant job experience (15 points)
    - Skills match with role (10 points)
    - Career progression (5 points)
    
    Strict Rules:
    - No assumptions about missing data
    - Zero points for unavailable information
    - Evidence required for every score
    - Clear justification for each assessment
"""

import streamlit as st

# Session state for API keys
for key in ["Nebius_api_key", "model_id", "github_api_key", "exa_api_key"]:
    if key not in st.session_state:
        st.session_state[key] = ""

# Create agent with user-provided credentials
if st.button("Analyze Candidates"):
    if not all([st.session_state.Nebius_api_key, 
                st.session_state.github_api_key, 
                st.session_state.exa_api_key]):
        st.error("Please enter all API keys")
    else:
        agent = Agent(
            model=Nebius(
                id=st.session_state.model_id,
                api_key=st.session_state.Nebius_api_key
            ),
            tools=[...],  # As shown above
        )

with st.spinner("Running analysis..."):
    output = ""
    block = st.empty()
    
    for chunk in agent.run(query, stream=True):
        if hasattr(chunk, "content") and isinstance(chunk.content, str):
            output += chunk.content
            block.markdown(output, unsafe_allow_html=True)

# Extract and display score
import re
match = re.search(r"\b([1-9]?\d|100)/100\b", output)
if match:
    score = int(match.group(1))
    st.success(f"Candidate Score: {score}/100")

import yaml

@st.cache_data
def load_yaml(file_path):
    with open(file_path, "r", encoding="utf-8") as file:
        return yaml.safe_load(file)

data = load_yaml("hiring_prompts.yaml")

# Load role-specific prompts
description_multi = data.get("description_for_multi_candidates")
instructions_multi = data.get("instructions_for_multi_candidates")
description_single = data.get("description_for_single_candidate")
instructions_single = data.get("instructions_for_single_candidate")

# Use in agent configuration
agent = Agent(
    description=description_single,
    instructions=instructions_single,
    # ... other config
)

instructions = """
    STRICT RULES:
    - If no experience found, say "No experience found"
    - If information unavailable, say "Not available"
    - Do NOT make up or assume any information
    - Evidence required for every statement
    - Only analyze what is explicitly present
"""

instructions = """
    DISCLAIMER: This agent should call the tool to get information.
    Once the tool is called and returns data, it should NOT call 
    the tool multiple times. Use the returned information to 
    complete the analysis.
"""

# .env or Streamlit sidebar
NEBIUS_API_KEY=your_nebius_key
GITHUB_API_KEY=your_github_token
EXA_API_KEY=your_exa_key

# For reasoning-heavy tasks
model = Nebius(id="deepseek-ai/DeepSeek-R1")

# For general analysis
model = Nebius(id="meta-llama/Llama-3.3-70B-Instruct")

candidate_analyser/
├── main.py                 # Streamlit app with agent logic
├── hiring_prompts.yaml     # Role-specific prompts and instructions
├── requirements.txt        # Dependencies
└── README.md              # Documentation