Implementation Guide: Analyze RFP Requirements Against Incumbent Capabilities — Bid/No-Bid & Gap Analysis

# Monitors SAM.gov API for new solicitations matching contractor
# qualification criteria

# sam_monitor.py
# Monitors SAM.gov API for new solicitations matching contractor qualification criteria

import requests
import os
import json
import datetime
import time

SAM_API_KEY = os.environ["SAM_GOV_API_KEY"]
SAM_BASE_URL = "https://api.sam.gov/opportunities/v2"

# Contractor opportunity qualification criteria
QUALIFICATION_CRITERIA = {
    "naics_codes": ["541511", "541512", "541513", "541519", "541330", "541690"],
    "min_value": 1_000_000,  # $1M minimum
    "max_value": 500_000_000,  # $500M maximum
    "set_aside_preferences": ["SBA", "SDVOSB", "WOSB", "EDWOSB", "8A", "NONE"],
    "excluded_agencies": [],  # Add agencies to exclude from monitoring
    "required_keywords": [],  # Optional: keywords that must appear in description
    "excluded_keywords": ["construction", "janitorial", "food service"],
    "notice_types": ["Solicitation", "Pre-Solicitation", "Sources Sought", "Special Notice"],
    "posted_within_days": 1  # Check for opportunities posted in the last day
}

def search_new_opportunities(criteria: dict) -> list:
    """Search SAM.gov for new opportunities matching criteria."""
    headers = {"X-Api-Key": SAM_API_KEY}

    cutoff_date = (datetime.datetime.now() - datetime.timedelta(
        days=criteria["posted_within_days"]
    )).strftime("%m/%d/%Y")

    opportunities = []

    for naics in criteria["naics_codes"]:
        params = {
            "naics": naics,
            "postedFrom": cutoff_date,
            "postedTo": datetime.datetime.now().strftime("%m/%d/%Y"),
            "ptype": ",".join(["o", "p", "k", "r"]),  # Solicitation, Pre-Sol, Sources Sought
            "limit": 100,
            "offset": 0
        }

        resp = requests.get(f"{SAM_BASE_URL}/search",
                           headers=headers, params=params)
        if resp.status_code == 200:
            data = resp.json()
            opps = data.get("opportunitiesData", [])

            for opp in opps:
                # Basic filtering
                title_lower = opp.get("title", "").lower()
                desc_lower = opp.get("description", "").lower()

                # Exclude if excluded keywords present
                if any(kw in title_lower or kw in desc_lower
                       for kw in criteria["excluded_keywords"]):
                    continue

                # Check required keywords if specified
                if criteria["required_keywords"]:
                    if not any(kw in title_lower or kw in desc_lower
                               for kw in criteria["required_keywords"]):
                        continue

                opportunities.append({
                    "notice_id": opp.get("noticeId"),
                    "title": opp.get("title"),
                    "agency": opp.get("department"),
                    "sub_agency": opp.get("subtier"),
                    "naics": naics,
                    "type": opp.get("type"),
                    "posted_date": opp.get("postedDate"),
                    "response_date": opp.get("responseDeadLine"),
                    "set_aside": opp.get("typeOfSetAsideDescription", "None"),
                    "place_of_performance": opp.get("placeOfPerformance", {}).get("city", {}).get("name", ""),
                    "sol_number": opp.get("solicitationNumber"),
                    "description": opp.get("description", "")[:2000],
                    "sam_url": f"https://sam.gov/opp/{opp.get('noticeId')}/view"
                })

        time.sleep(0.5)  # Rate limit compliance

    # Deduplicate by notice_id
    seen = set()
    unique_opps = []
    for opp in opportunities:
        if opp["notice_id"] not in seen:
            seen.add(opp["notice_id"])
            unique_opps.append(opp)

    return unique_opps


def download_solicitation_documents(notice_id: str) -> list:
    """Download attachments for a specific opportunity."""
    headers = {"X-Api-Key": SAM_API_KEY}
    resp = requests.get(
        f"{SAM_BASE_URL}/{notice_id}",
        headers=headers
    )
    if resp.status_code != 200:
        return []

    opp_data = resp.json()
    attachments = []

    for resource in opp_data.get("resourceLinks", []):
        url = resource.get("url", "")
        name = resource.get("name", "")
        if url:
            attachments.append({"name": name, "url": url})

    return attachments

# bid_no_bid_analyzer.py

from openai import AzureOpenAI
import os, json

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-08-01-preview"
)

BID_NO_BID_SYSTEM_PROMPT = """You are a defense contractor capture management specialist
with expertise in federal procurement and BD strategy. Analyze government solicitations
to produce rigorous, data-driven bid/no-bid recommendations.

RULES:
- Base all assessments strictly on the solicitation document and capability library provided
- Do not fabricate competitor intelligence or past performance data not in the inputs
- Be direct — if the company lacks a critical capability, say so clearly
- Win probability estimates must be accompanied by specific rationale
- Flag any assumptions with [ASSUMPTION]
- Flag any data gaps that would improve the analysis with [DATA NEEDED]"""

def generate_bid_no_bid_analysis(
    opportunity: dict,
    solicitation_text: str,
    capability_library: dict
) -> str:

    capability_summary = json.dumps(capability_library, indent=2)
    opp_summary = json.dumps(opportunity, indent=2)

    analysis_prompt = f"""Analyze this federal opportunity and produce a complete bid/no-bid assessment.

OPPORTUNITY METADATA:
{opp_summary}

SOLICITATION DOCUMENT (key sections):
{solicitation_text[:6000]}

COMPANY CAPABILITY LIBRARY:
{capability_summary}

Generate a complete Bid/No-Bid Analysis Report with the following sections:

## EXECUTIVE SUMMARY
- Recommended Decision: BID / NO BID / CONDITIONAL BID
- Win Probability Estimate: X% (with confidence: High/Medium/Low)
- One-sentence rationale for recommendation

## OPPORTUNITY PROFILE
- Estimated contract value and type (FFP/CPFF/T&M/IDIQ)
- Period of performance
- Key requirements summary (5 bullets)
- Set-aside status and implications
- Required clearances
- Place of performance
- Key evaluation factors (from Section M) ranked by weight

## COMPANY FIT ASSESSMENT
Score each dimension 1-5 (1=Poor, 5=Excellent):
- Technical capability match: [score] — [rationale]
- Past performance relevance: [score] — [rationale with specific past contracts]
- Key personnel availability: [score] — [rationale]
- Security clearance alignment: [score] — [rationale]
- Contract vehicle alignment: [score] — [rationale]
- Geographic/place of performance match: [score] — [rationale]
- Incumbent advantage/disadvantage: [score] — [rationale]

Overall Fit Score: [average]/5

## CAPABILITY GAPS
For each gap identified:
- Gap description
- Impact on win probability (High/Medium/Low)
- Mitigation options: [teaming partner, hire, partnership, etc.]

## COMPETITIVE LANDSCAPE
- Likely incumbent (if identifiable from solicitation language or FPDS)
- Likely competitors based on requirement profile
- Our competitive differentiators
- Competitor advantages we must overcome

## WIN STRATEGY ELEMENTS (if BID recommended)
- Top 3 discriminating win themes
- Teaming recommendations (capabilities to acquire via teaming)
- Pricing strategy guidance (FFP competitiveness, T&M rate considerations)
- Key risks and mitigations

## CAPTURE ACTIONS REQUIRED
If BID: List specific next actions with owners and due dates
If NO BID: Brief rationale and flag for future pipeline if requirements evolve

## QUESTIONS FOR GOVERNMENT
List the top 5 questions to submit during any industry day or Q&A period

[DRAFT — REQUIRES CAPTURE MANAGER REVIEW AND BD DIRECTOR APPROVAL BEFORE GATE REVIEW]"""

    response = client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[
            {"role": "system", "content": BID_NO_BID_SYSTEM_PROMPT},
            {"role": "user", "content": analysis_prompt}
        ],
        temperature=0.2,
        max_tokens=4000
    )

    return response.choices[0].message.content


def score_opportunity_fit(opportunity: dict, capability_library: dict) -> dict:
    """Quick-score an opportunity for pipeline triage before full analysis."""

    score_prompt = f"""Score this opportunity for a quick pipeline triage (1 minute analysis).

OPPORTUNITY: {json.dumps(opportunity)}
CAPABILITIES: {json.dumps(capability_library.get('summary', capability_library))[:2000]}

Return JSON only:
{{
  "quick_score": [1-10],
  "go_no_go": "GO | NO-GO | INVESTIGATE",
  "top_reasons_go": ["reason 1", "reason 2"],
  "top_reasons_no_go": ["reason 1", "reason 2"],
  "recommended_next_action": "Full analysis | Pass | Watch | Industry Day only"
}}"""

    response = client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[{"role": "user", "content": score_prompt}],
        temperature=0.0,
        max_tokens=400,
        response_format={"type": "json_object"}
    )

    return json.loads(response.choices[0].message.content)

# compliance_matrix_generator.py

def generate_lm_compliance_matrix(
    section_l_text: str,
    section_m_text: str,
    sow_pws_text: str
) -> dict:
    """Generate a compliance matrix from RFP Sections L and M."""

    matrix_prompt = f"""Extract and structure all proposal requirements from the following
RFP sections into a compliance matrix.

SECTION L — INSTRUCTIONS TO OFFERORS:
{section_l_text[:3000]}

SECTION M — EVALUATION CRITERIA:
{section_m_text[:2000]}

SOW/PWS — TECHNICAL REQUIREMENTS:
{sow_pws_text[:2000]}

Generate a JSON compliance matrix with this structure:
{{
  "volumes": [
    {{
      "volume_name": "Technical",
      "page_limit": "X pages or 'Not specified'",
      "requirements": [
        {{
          "req_id": "L-1.1",
          "source": "Section L paragraph reference",
          "requirement_text": "exact or paraphrased requirement",
          "proposal_section": "suggested proposal section heading",
          "evaluation_criterion": "matching Section M criterion if applicable",
          "evaluation_weight": "percentage or 'Not specified'",
          "compliance_method": "how this will be addressed (narrative/table/chart/attachment)",
          "page_estimate": "estimated pages",
          "owner": "TBD — assign to volume lead",
          "status": "Not Started"
        }}
      ]
    }}
  ],
  "key_attachments_required": ["list of required attachments, forms, certifications"],
  "submission_requirements": {{
    "format": "electronic/paper/both",
    "delivery_method": "SAM.gov/email/hand delivery",
    "copies_required": "N",
    "due_date": "extract from Section L",
    "page_limits_summary": "summary of all volume page limits"
  }},
  "evaluation_criteria_summary": [
    {{
      "criterion": "criterion name",
      "weight_or_order": "percentage or order of importance",
      "description": "how the government will evaluate"
    }}
  ]
}}"""

    response = client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[{"role": "user", "content": matrix_prompt}],
        temperature=0.0,
        max_tokens=4000,
        response_format={"type": "json_object"}
    )

    return json.loads(response.choices[0].message.content)


def export_matrix_to_markdown(matrix: dict) -> str:
    """Export compliance matrix as a Markdown table for SharePoint storage."""
    md = "# Proposal Compliance Matrix\n\n"
    md += "[DRAFT — REQUIRES PROPOSAL MANAGER REVIEW]\n\n"

    for volume in matrix.get("volumes", []):
        md += f"## {volume['volume_name']} Volume\n"
        md += f"**Page Limit:** {volume.get('page_limit', 'TBD')}\n\n"
        md += "| Req ID | Requirement | Eval Criterion | Method | Pages | Owner | Status |\n"
        md += "|--------|------------|----------------|--------|-------|-------|--------|\n"

        for req in volume.get("requirements", []):
            md += f"| {req['req_id']} | {req['requirement_text'][:60]}... | "
            md += f"{req.get('evaluation_criterion', 'N/A')} | "
            md += f"{req.get('compliance_method', 'TBD')} | "
            md += f"{req.get('page_estimate', 'TBD')} | "
            md += f"{req.get('owner', 'TBD')} | "
            md += f"{req.get('status', 'Not Started')} |\n"

        md += "\n"

    return md

SYSTEM PROMPT:
You are a federal procurement intelligence analyst. Analyze the following solicitation
for signals of incumbent contractor advantage.

Look for these indicators:
1. REQUIREMENTS SPECIFICITY — Are requirements written around very specific existing systems, tools, or processes that suggest an incumbent designed them?
2. TRANSITION REQUIREMENTS — Is a long transition period required (suggests complex existing work)?
3. KEY PERSONNEL — Do key personnel requirements match a specific person's resume profile?
4. PAST PERFORMANCE — Does the past performance requirement description match only one contractor's specific experience?
5. AWARD HISTORY — Does the solicitation reference a prior contract number (check USASpending.gov)?
6. LANGUAGE PATTERNS — Are there unusual technical terms, abbreviations, or trademarked tool names that suggest an incumbent's terminology?

For each signal found:
- Describe the signal
- Rate incumbent advantage strength: Strong / Moderate / Weak / None
- Identify the likely incumbent if determinable
- Estimate impact on non-incumbent win probability

Conclude with an Incumbent Advantage Score (1-10, where 10 = impossible for non-incumbent)
and specific strategies to overcome the incumbent's advantage.

SOLICITATION TEXT:
{solicitation_text}