At my company, I worked on a project involving a customer inquiry form for e-commerce site. We had a system in place to verify email addresses, but a bigger problem remained: how to ensure the messages people sent were actually relevant to store and not just junk mail. This was crucial to avoid overwhelming our support team with irrelevant emails.
The core challenge, and the focus of this component, was developing a method to automatically assess the relevance of each inquiry before it even reached our inbox – essentially, a spam filter for customer questions, focused on keeping only the genuinely relevant messages.
My first attempt at solving the problem was pretty straightforward: I used standard email validation techniques. This meant checking for common spam email patterns and making sure the email address was properly formatted. It caught some obvious spam, but it wasn't foolproof. Clever spam emails easily bypassed these simple checks.
The key problem was that I was only looking at the address, not the message itself. To really solve this, I needed to understand the content of the email, which is where I started using AI.
Get your api-key from here - AISTUDIO
Demo video - videoLink
Building the AI-Powered Validator using GEMINI 1.5 FLASH MODEL
The heart of my solution is surprisingly simple, but effective.
- Rate Limiting: It starts with preventing abuse, something I addressed using rate limiting. Basically, the system now keeps track of how many messages it receives from a single email address within a short time period (five minutes, in this case).
- Crafting the Prompt: I created a specific set of instructions – a "prompt" – to tell the AI exactly what to look for in each email. This prompt includes the sender's name, email address, and the message itself. Then, I ask the AI some key questions:
Analyze this email:
Name: [Sender's Name]
Email: [Sender's Email]
Message: [Email Message]
Is this message relevant to [domain/topic]?
Does the email address look legitimate?
Is the inquiry specific and reasonable?
Return JSON: {"is_valid": "Yes/No", "reason": "[Explanation]"}
Interacting with the AI: I used a popular AI model(Gemini 1.5 Flash Model) (you can easily adapt this to others), sending it the prompt and receiving a JSON response. This response contains two key pieces of information: is_valid (Yes or No) and reason (an explanation of the AI's decision).
Error Handling: Unexpected things happen! My code includes robust error handling. If the AI API call fails, or the AI's response is unexpected, the system gracefully handles the error and prevents crashes. It returns an error message instead of failing silently.
Putting it All Together: The final system is elegant in its simplicity: An email comes in -> Rate limiting check -> AI validation -> Decision (valid/invalid). This approach is far more accurate than simple email validation alone.
Implementation Code
class EmailValidator {
static rateLimitMap = new Map();
static isRateLimited(email, timeLimit = 5 * 60 * 1000) { // Default 5 minutes
const now = Date.now();
const lastAttempt = this.rateLimitMap.get(email) || 0;
if (now - lastAttempt < timeLimit) {
return true;
}
this.rateLimitMap.set(email, now);
return false;
}
static async validateWithAI(name, email, message) {
// Replace with your actual API key retrieval method. This example shows a placeholder.
const apiKey = await this.getApiKey();
if (!apiKey) {
throw new Error('API key not found');
}
const prompt = `Analyze this email:
Name: ${name}
Email: ${email}
Message: ${message}
Is the message relevant?
Does the email address look legitimate?
Is the inquiry reasonable?
Return JSON only:
{
"is_valid": "Yes/No",
"reason": "[Reason]"
}`;
const requestBody = {
//Adapt to your AI model's requirements
contents: [{ role: "user", parts: [{ text: prompt }] }],
generationConfig: {
//Model specific parameters
temperature: 0.9,
topK: 40,
topP: 0.8,
maxOutputTokens: 2048,
responseMimeType: "text/plain"
}
};
try {
const response = await fetch(
`[YOUR_AI_API_ENDPOINT]?key=${apiKey}`, //Replace with your actual API endpoint
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(requestBody)
}
);
if (!response.ok) {
throw new Error(`API request failed: ${response.statusText}`);
}
const data = await response.json();
//Adapt to your AI model's response structure
const aiResponse = this.extractAIResponse(data);
return aiResponse; //Should be {is_valid: "Yes"/"No", reason: "..."}
} catch (error) {
console.error('AI validation error:', error);
return { is_valid: "No", reason: "Error processing message validation" };
}
}
//Helper function to extract relevant data from AI response
static extractAIResponse(data){
//Implement your logic to parse the AI's response here. This will vary based on the AI model.
//Example (assuming a specific structure):
return { is_valid: data.candidates[0].content.parts[0].text.includes("Yes") ? "Yes" : "No", reason: data.candidates[0].content.parts[0].text };
}
static async validateEmailAndMessage(name, email, message) {
try {
if (this.isRateLimited(email)) {
return { success: false, message: 'Please wait before sending another message.' };
}
const aiValidation = await this.validateWithAI(name, email, message);
return {
success: aiValidation.is_valid === "Yes",
message: aiValidation.reason,
shouldSendEmail: aiValidation.is_valid === "Yes"
};
} catch (error) {
console.error('Validation error:', error);
return { success: false, message: 'Validation service unavailable', shouldSendEmail: false };
}
}
// Placeholder for API key retrieval - replace with your actual implementation
static async getApiKey() {
// Your logic to fetch API Key from environment variables or a secure configuration store goes here.
// Example (using environment variables):
return process.env.AI_API_KEY;
}
}
export default EmailValidator;
Remember to replace the placeholders:
[YOUR_AI_API_ENDPOINT] with the actual endpoint of your AI API.
The getApiKey() function with your method for securely accessing the API key.
The extractAIResponse() function with code specific to parsing the response from your chosen AI model. The example provided is illustrative and may not work directly with your AI model's response.
Above code is just the basic approach how to reduce the spam emails it needs refinement which caters your need.
Thank You🙏
Top comments (0)