Requirements for Final Project

​

Project summary

• Goal: Build an internal support assistant that answers employee questions using a curated knowledge base and Amazon Bedrock, while enforcing safety and predictable formatting.
• Deliverables:
  • A Flask-based web frontend to accept questions and show answers.
  • Backend logic to validate inputs, retrieve supporting documents, call Bedrock securely, post-process outputs, and return answers with source attributions.
  • Safety filters both pre- and post-model invocation.

​

Technology stack

• Python 3.x
• Flask (lightweight web framework)
• AWS Bedrock (for LLM runtime)
• Vector store or keyword-based retrieval for knowledge base
• VM-based compute instance with an IAM role (no hard-coded credentials)

​

Minimal Flask skeleton

from flask import Flask, request, render_template, jsonify

app = Flask(__name__)

@app.route("/")
def index():
    return render_template("index.html")

@app.route("/ask", methods=["POST"])
def ask():
    question = request.form.get("question", "").strip()
    # 1) filter/validate user input
    # 2) fetch relevant docs from the knowledge base (keyword or embeddings)
    # 3) compose prompt and call Bedrock runtime via boto3 or AWS SDK
    # 4) post-process and filter model output
    # 5) return JSON with answer and sources
    return jsonify({"answer": "TBD", "sources": []})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

​

Non-functional requirements

• Ensure the VM runs with an IAM role that grants Bedrock permissions — never hard-code AWS credentials.
• Use model parameters (max_tokens, temperature, top_p, stop) to control output length, randomness, and formatting.
• Enforce predictable structure in responses (for example, returning structured JSON with answer, steps, and sources).

​

Architecture overview

1. End user submits a question via the web UI.
2. Flask app validates and sanitizes the input.
3. The app queries the knowledge base (local files, vector store, or document store) to find relevant passages.
4. The app composes a prompt that includes context and sources, then calls the Bedrock runtime via the AWS SDK for Python.
5. Bedrock returns a generated response; the app post-processes and filters that response.
6. The app returns the final answer plus source attributions to the UI.

• Input validation and safety filtering
• Retrieval and ranking of supporting documents
• Prompt composition and model parameter tuning
• Post-processing, output filtering, and formatting
• Logging and auditable source attribution

​

Safety and filtering

• Remove or block disallowed tokens/patterns and illegal or abusive requests.
• Enforce length limits and sanitize HTML or script content.
• Normalize whitespace and strip control characters.

• Redact or remove unsafe content (profanity, PII, disallowed instructions).
• Verify that factual claims are supported by at least one retrieved source before presenting them as facts.
• Ensure the response matches required formatting and length constraints.

• Keep a deny-list of patterns and a separate allow-list for permitted content types.
• When in doubt about a model claim, return a conservative answer with a disclaimer and link to the source documents.
• Log both inputs and model outputs (with access controls) for audit and debugging.

​

User interface and example output

{
  "answer": "To request VPN access, submit a request through ServiceHub. Approval is required from your line manager and the IT Access Approvers group.",
  "steps": [
    "Log in to ServiceHub",
    "Navigate to Access Requests",
    "Select VPN Access",
    "Fill out the request form",
    "Submit the request for approval"
  ],
  "escalation": "Contact the IT Service Desk for assistance.",
  "sources": ["acceptable_use.txt", "onboarding.txt", "vpn_access.txt"]
}

1. To request VPN access, submit a request through ServiceHub. Approval is required from your line manager and the IT Access Approvers group.
2. Steps:
   • Log in to ServiceHub
   • Navigate to Access Requests
   • Select VPN Access
   • Fill out the request form
   • Submit the request for approval
3. Escalation: Contact the IT Service Desk for assistance.

​

Implementation guidance and expectations

• Knowledge base:
  • Build or reuse a knowledge base from the supplied text documents.
  • Retrieval options: simple keyword search, embeddings + vector store, or a document store. Ensure relevance and include correct attributions.
• Bedrock integration:
  • Use the AWS SDK for Python to call the Bedrock runtime from your Flask app.
  • Make sure the VM’s IAM role has the necessary Bedrock permissions.
• Model control:
  • Configure max_tokens, temperature, top_p, and stop sequences to produce concise, consistent answers.
  • Test and iterate on prompts to ensure clear, source-backed responses.
• Formatting and auditability:
  • Return a JSON structure with answer, steps (optional), and sources.
  • Provide clear source attributions so users can verify claims.
• Frontend:
  • Keep it simple — the UI should render the structured JSON response. Focus engineering effort on backend correctness, safety, and Bedrock integration.

​

Next steps

1. Implement the retrieval pipeline for your knowledge base.
2. Wire up the Flask endpoints to call Bedrock securely (use IAM role auth).
3. Add pre- and post-filters to handle unsafe content and sensitive data.
4. Iterate on prompts and model parameters until responses are consistent and well-attributed.
5. Add logging and monitoring for auditability.

​

Links and references

• Amazon Bedrock documentation
• Flask documentation
• AWS SDK for Python (boto3)