AWS Builder Center
GramSankalpa - Weather, Earth & AI for Better Decisions

GramSankalpa - Weather, Earth & AI for Better Decisions

GramSankalpa combines village-level weather, satellite, and geospatial data with Amazon Bedrock to generate localized agricultural insights, helping farmers and local decision-makers understand risks and make more informed decisions.

B.Tech @PICT | GSSoC ’26 Contributor | Backend Developer | MERN Stack | Docker | 1x Hackathon Winner

GramSankalpa: Weather, Earth & AI for Better Decisions

Introduction

Agriculture depends heavily on local environmental conditions. However, farmers and local decision-makers often have to work with information that is scattered across different platforms, available at a broad regional level, or difficult to interpret.
GramSankalpa is an AI-powered village intelligence platform designed to turn weather, satellite, and geospatial data into simple, localized agricultural insights.
The idea is straightforward:
Instead of asking a farmer to interpret multiple data sources, GramSankalpa combines those sources and presents the important information in an understandable and actionable form.
The platform focuses on village-level context, helping users understand current weather conditions, environmental indicators, potential agricultural risks, and crop-related recommendations.



The Problem

Farmers make decisions based on several interconnected factors:
  • Weather conditions
  • Rainfall
  • Temperature
  • Soil and water conditions
  • Crop requirements
  • Vegetation health
  • Environmental risks
The problem is that these datasets usually exist independently.
A weather application may provide a forecast, while satellite platforms provide vegetation or water-related information. Agricultural resources may provide crop recommendations, but connecting all of these sources together requires technical knowledge.
This creates a gap between available data and usable information.
GramSankalpa aims to bridge that gap by creating a single platform where village-level environmental data can be processed and converted into understandable insights.



Our Solution

GramSankalpa follows a data-to-intelligence pipeline.
A user selects a village or geographic location. The system then collects and processes relevant environmental information.
The overall flow is:
Village / Location
↓
Weather Data
↓
Satellite & Geospatial Data
↓
Data Processing
↓
Village-Level Context
↓
Amazon Bedrock
↓
AI-Generated Agricultural Insights
↓
Farmer / Local Decision-Maker

Instead of exposing raw datasets to the user, GramSankalpa attempts to answer practical questions such as:
  • What are the current environmental conditions?
  • What weather-related risks should be considered?
  • What does the available vegetation information indicate?
  • How can the available information be interpreted for agriculture?
  • What crops or agricultural actions may be suitable under the given conditions?



System Architecture

The platform is designed around separate components for the frontend, backend, data processing, geospatial analysis, and AI generation.

┌──────────────────────┐
│ User / Farmer │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ React Frontend │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ FastAPI Backend │
└──────────┬───────────┘
│
┌─────────────────┼─────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌───────────────┐ ┌──────────────┐
│ Weather Data │ │ Geospatial / │ │ MongoDB │
│ │ │ Satellite Data│ │ │
└──────────────┘ └───────┬───────┘ └──────────────┘
│
▼
┌──────────────────────┐
│ Data Processing & │
│ Context Generation │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Amazon Bedrock │
│ Generative AI │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Localized Advisory │
└──────────────────────┘

The architecture separates data collection and processing from AI generation. This allows the AI model to receive structured and relevant information rather than relying on unprocessed raw data.



Build It: Open-Source Technology Stack

We built GramSankalpa using a combination of open-source development frameworks and geospatial tools.

Frontend

The user interface is built using React, providing an interactive interface for selecting locations, viewing environmental information, and accessing AI-generated insights.
The frontend is designed with a focus on simplicity because the target users may not be familiar with complex data dashboards.

Backend

The backend uses Python and FastAPI.
FastAPI provides REST APIs that connect the frontend with the data-processing and AI components.
The backend is responsible for tasks such as:
  • Receiving location information
  • Calling data sources
  • Processing environmental information
  • Preparing structured context
  • Communicating with the AI layer
  • Returning results to the frontend

Geospatial Processing

Geospatial processing is an important part of GramSankalpa.
We use open-source Python libraries including:
  • GeoPandas
  • Shapely
  • PyProj
These tools help us work with geographic boundaries, coordinates, projections, and spatial data.
For example, a geographic location can be transformed into a structured representation that allows the system to associate environmental information with a particular village or region.

Satellite Data

GramSankalpa also uses satellite and geospatial information to provide additional environmental context.
Satellite-derived indicators can provide information related to vegetation, water, and land conditions.
We use Google Earth Engine APIs as part of the data-processing pipeline to work with geospatial and satellite datasets.
This allows GramSankalpa to go beyond simply displaying a weather forecast.



Ship It: Using AWS

AWS provides the cloud and generative AI capabilities used by GramSankalpa.
One of the key AWS services in our project is Amazon Bedrock.

Amazon Bedrock

Amazon Bedrock is used as the generative AI layer of GramSankalpa.
The application first collects relevant information such as:
  • Location
  • Weather conditions
  • Rainfall-related information
  • Environmental indicators
  • Satellite-derived information
  • Agricultural context
Instead of directly sending unrelated raw information to the model, the backend prepares this information as structured context.
The context is then provided to Amazon Bedrock, which generates an easy-to-understand response.
Conceptually:
Weather + Satellite + Geospatial Data
↓
Context Builder
↓
Structured AI Prompt
↓
Amazon Bedrock
↓
Agricultural Insight

This architecture allows the AI layer to focus on interpreting the available data rather than being responsible for collecting it.



Why Generative AI?

Traditional rule-based systems can provide fixed recommendations:
IF temperature > X
AND rainfall < Y
THEN show recommendation Z

However, agricultural situations can involve multiple variables simultaneously.
For example, a user may need to understand a combination of:
  • Current temperature
  • Rainfall
  • Upcoming weather
  • Vegetation condition
  • Water availability
  • Crop requirements
Generative AI allows GramSankalpa to combine these pieces of information and explain them in natural language.
The goal is not simply to generate text.
The goal is to transform complex environmental information into a form that is easier for users to understand.



Localized Intelligence

One of the important ideas behind GramSankalpa is localization.
A generic agricultural recommendation may not be equally useful for every location.
The platform therefore uses geographic context as an important part of its processing pipeline.
For example:
Region A
→ Weather + Satellite Data
→ Local Context
→ AI Interpretation

Region B
→ Weather + Satellite Data
→ Different Local Context
→ AI Interpretation

This makes the platform more focused on village-level intelligence rather than generic agricultural information.



Example User Journey

Consider a farmer selecting their village on GramSankalpa.

Step 1 — Select Location

The user selects a village or location.

Step 2 — Collect Data

The system retrieves relevant environmental information for that geographic area.

Step 3 — Process Data

The backend processes the weather, satellite, and geospatial information.

Step 4 — Build Context

The processed information is converted into structured context for the AI system.

Step 5 — Generate Insight

Amazon Bedrock generates a natural-language interpretation of the available information.

Step 6 — Display Result

The user receives the information through the GramSankalpa interface in a simpler and more understandable form.



Making Complex Data Understandable

A major design principle of GramSankalpa is:
Raw data is useful to machines, but decisions require understandable information.
For example, instead of requiring a user to interpret multiple satellite indicators and weather values independently, GramSankalpa can present their combined meaning through an AI-generated explanation.
This creates a pipeline:
Raw Data
↓
Processed Data
↓
Context
↓
AI Interpretation
↓
Human-Readable Insight

The system therefore acts as a bridge between environmental datasets and end users.



Challenges We Faced

Building GramSankalpa involved several technical challenges.

1. Working with Geospatial Data

Geographic data can use different coordinate systems, projections, and formats.
Libraries such as GeoPandas, Shapely, and PyProj helped us handle these transformations and spatial operations.

2. Combining Multiple Data Sources

Weather, satellite, and geographic information come from different sources and formats.
A major part of the backend work was creating a consistent data-processing flow.

3. Turning Data into Useful Context

Sending large amounts of raw information to an AI model does not automatically produce useful results.
We therefore designed the backend to process and structure the information before passing it to Amazon Bedrock.

4. Designing for Non-Technical Users

The platform is intended for users who may not understand technical environmental indicators.
Therefore, the interface and AI responses need to prioritize clarity over technical complexity.



What We Learned

Working on GramSankalpa helped us understand that building an AI application is not only about selecting an AI model.
A useful AI system requires:
  1. Reliable input data
  1. Data processing
  1. Context construction
  1. Appropriate prompting
  1. AI generation
  1. Clear presentation
  1. Human understanding
Our architecture reflects this idea.
Data
↓
Processing
↓
Context
↓
AI
↓
Explanation
↓
Decision Support




Future Improvements

There are several directions in which we plan to extend GramSankalpa.

Local-Language Interaction

We want to make agricultural insights accessible in regional languages such as Marathi and Hindi.

Voice-Based Interaction

A voice interface could make the platform easier to use for users who are less comfortable with text-based applications.

Historical Analysis

Historical weather and satellite information could be used to identify trends rather than only displaying current conditions.

Early-Warning System

The platform could generate alerts for potential weather and agricultural risks.

More Agricultural Data

Future versions could incorporate additional crop, soil, irrigation, and agricultural datasets.

Improved Personalization

Recommendations could eventually consider crop type, growth stage, local conditions, and other user-provided information.



Conclusion

GramSankalpa is our attempt to build a bridge between environmental data and agricultural decision-making.
By combining:
  • React
  • Python
  • FastAPI
  • Geospatial processing
  • Satellite data
  • Google Earth Engine
  • MongoDB
  • Amazon Bedrock
we created a platform that converts multiple sources of village-level information into localized, understandable agricultural insights.
The key idea behind GramSankalpa is simple:
Make complex environmental intelligence easier to understand at the village level.
AWS, particularly Amazon Bedrock, provides the generative AI capability that helps transform structured environmental context into natural-language insights.
As we continue developing the project, our goal is to make GramSankalpa more localized, multilingual, accessible, and useful for communities that depend on agriculture and environmental information.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article