Adjusted backend and frontend for new plots

backend/main.py

@@ -52,13 +52,13 @@ class Settings(SettingsBase):
     Configuration settings loaded from environment or .env file.
     """
     # Data sources
-    parquet_path: str = "gs://mda_eu_project/data/consolidated_clean_pred.parquet"
-    whoosh_dir: str = "gs://mda_eu_project/whoosh_index"
-    vectorstore_path: str = "gs://mda_eu_project/vectorstore_index"
+    parquet_path: str = "gs://mda_kul_project/data/consolidated_clean_pred.parquet"
+    whoosh_dir: str = "gs://mda_kul_project/whoosh_index"
+    vectorstore_path: str = "gs://mda_kul_project/vectorstore_index"
 
     # Model names
     embedding_model: str = "sentence-transformers/LaBSE"
-    llm_model: str = "google/flan-t5-base"
+    llm_model: str = "google/mt5-base"
     cross_encoder_model: str = "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
 
     # RAG parameters
@@ -305,6 +305,7 @@ def get_projects(
     country: str = "",
     fundingScheme: str = "",
     proj_id: str = "",
+    topic: str = "",
     sortOrder: str = "desc",
     sortField: str = "startDate",
 ):
@@ -317,6 +318,7 @@ def get_projects(
     - search: substring search in project title
     - status, legalBasis, organization, country, fundingScheme: filters
     - proj_id: exact project ID filter
+    - topic: filter by EuroSciVoc topic
     - sortOrder: 'asc' or 'desc'
     - sortField: field name to sort by (fallback to startDate)
 
@@ -344,6 +346,8 @@ def get_projects(
         sel = sel.filter(pl.col("_fundingScheme_lc").str.contains(fundingScheme.lower()))
     if proj_id:
         sel = sel.filter(pl.col("id") == int(proj_id))
+    if topic:
+        sel = sel.filter(pl.col("list_euroSciVocTitle").list.contains(topic))
 
     # Base columns to return
     base_cols = [
@@ -410,6 +414,8 @@ def get_filters(request: Request):
         df = df.filter(pl.col("list_name").list.contains(org))
     if c := params.get("country"):
         df = df.filter(pl.col("list_country").list.contains(c))
+    if t := params.get("topics"):
+        df = df.filter(pl.col("list_euroSciVocTitle").list.contains(t))
     if search := params.get("search"):
         df = df.filter(pl.col("_title_lc").str.contains(search.lower()))
 
@@ -420,57 +426,175 @@ def get_filters(request: Request):
     return {
         "statuses":     normalize(df["status"].to_list()),
         "legalBases":   normalize(df["legalBasis"].to_list()),
-        "organizations": normalize(df["list_name"].explode().to_list())[:500],
+        "organizations": normalize(df["list_name"].explode().to_list()),
         "countries":    normalize(df["list_country"].explode().to_list()),
         "fundingSchemes": normalize(df["fundingScheme"].explode().to_list()),
+        "topics":       normalize(df["list_euroSciVocTitle"].explode().to_list()),
     }
 
 @app.get("/api/stats")
 def get_stats(request: Request):
     """
-    Compute annual statistics on projects with optional filters for status, legal basis, etc.
-
-    Returns a dict of chart data for projects per year.
+    Compute various statistics on projects with optional filters for status, legal basis, funding, etc.
+    Returns a dict of chart data.
     """
-    lf = app.state.df.lazy()
+    df = app.state.df
+    lf = df.lazy()
     params = request.query_params
 
-    # Apply lazy filters
+    # Apply filters
     if s := params.get("status"):
         lf = lf.filter(pl.col("_status_lc") == s.lower())
+        df = df.filter(pl.col("_status_lc") == s.lower())
     if lb := params.get("legalBasis"):
         lf = lf.filter(pl.col("_legalBasis_lc") == lb.lower())
+        df = df.filter(pl.col("_legalBasis_lc") == lb.lower())
     if org := params.get("organization"):
         lf = lf.filter(pl.col("list_name").list.contains(org))
+        df = df.filter(pl.col("list_name").list.contains(org))
     if c := params.get("country"):
         lf = lf.filter(pl.col("list_country").list.contains(c))
+        df = df.filter(pl.col("list_country").list.contains(c))
     if mn := params.get("minFunding"):
         lf = lf.filter(pl.col("ecMaxContribution") >= int(mn))
+        df = df.filter(pl.col("ecMaxContribution") >= int(mn))
     if mx := params.get("maxFunding"):
         lf = lf.filter(pl.col("ecMaxContribution") <= int(mx))
+        df = df.filter(pl.col("ecMaxContribution") <= int(mx))
     if y1 := params.get("minYear"):
         lf = lf.filter(pl.col("startDate").dt.year() >= int(y1))
+        df = df.filter(pl.col("startDate").dt.year() >= int(y1))
     if y2 := params.get("maxYear"):
         lf = lf.filter(pl.col("startDate").dt.year() <= int(y2))
+        df = df.filter(pl.col("startDate").dt.year() <= int(y2))
+
+    # 1) Projects per Year (Line)
+    yearly = (
+        lf
+        .select(pl.col("startDate").dt.year().alias("year"))
+        .group_by("year")
+        .agg(pl.count().alias("count"))
+        .sort("year")
+        .collect()
+    )
+    years = yearly["year"].to_list()
+    year_counts = yearly["count"].to_list()
+
+    # 2) Project-Size Distribution by totalCost buckets (Bar)
+    size_buckets = (
+        df
+        .with_columns(
+            pl.when(pl.col("totalCost") < 100_000).then("<100 K")
+             .when(pl.col("totalCost") < 500_000).then("100 K–500 K")
+             .when(pl.col("totalCost") < 1_000_000).then("500 K–1 M")
+             .when(pl.col("totalCost") < 5_000_000).then("1 M–5 M")
+             .when(pl.col("totalCost") < 10_000_000).then("5 M–10 M")
+             .otherwise("≥10 M")
+             .alias("size_range")
+        )
+        .group_by("size_range")
+        .agg(pl.count().alias("count"))
+        # ensure our custom order
+        .with_columns(
+            pl.col("size_range").apply(
+                lambda x: ["<100 K","100 K–500 K","500 K–1 M","1 M–5 M","5 M–10 M","≥10 M"].index(x)
+            ).alias("order")
+        )
+        .sort("order")
+        .collect()
+    )
+    size_labels = size_buckets["size_range"].to_list()
+    size_counts = size_buckets["count"].to_list()
+
+    # 3) EU Co-funding Ratio by Scheme (Bar)
+    #  a) First, filter out bad records and compute ratio:
+    clean = (
+        df
+        # drop if either value is null or totalCost is zero
+        .filter(
+            pl.col("ecMaxContribution").is_not_null() &
+            pl.col("totalCost").is_not_null() &
+            (pl.col("totalCost") != 0)
+        )
+        # compute ecMaxContributionRatio as Float64
+        .with_columns(
+            (
+                pl.col("ecMaxContribution").cast(pl.Float64)
+                / pl.col("totalCost").cast(pl.Float64)
+            ).alias("ecMaxContributionRatio")
+        )
+    )
+
+    #  b) Explode by scheme and aggregate the mean of ratio
+    ratio = (
+        clean
+        .explode("fundingScheme")
+        .group_by("fundingScheme")
+        .agg(
+            pl.col("ecMaxContributionRatio").mean().alias("avg_ratio")
+        )
+        .sort("avg_ratio", descending=True)
+        .head(10)
+        .collect()
+    )
 
-    # Group by year and count
-    grouped = (
-        lf.select(pl.col("startDate").dt.year().alias("year"))
-          .group_by("year")
-          .agg(pl.count().alias("count"))
-          .sort("year")
-          .collect()
+    scheme_labels = ratio["fundingScheme"].to_list()
+    scheme_values = (ratio["avg_ratio"] * 100).round(1).to_list()  # now in percentage
+
+
+    # 4) Top 10 Macro Topics by EC Contribution (Bar)
+    top_topics = (
+        df
+        .explode("list_euroSciVocTitle")
+        .group_by("list_euroSciVocTitle")
+        .agg(pl.col("ecMaxContribution").sum().alias("total_ec"))
+        .sort("total_ec", descending=True)
+        .head(10)
+        .collect()
+    )
+    topic_labels = top_topics["list_euroSciVocTitle"].to_list()
+    topic_values = (top_topics["total_ec"] / 1e6).round(1).to_list()
+
+    # 5) Projects by Funding Range (Pie)
+    fund_range = (
+        df
+        .with_columns(
+            pl.when(pl.col("ecMaxContribution") < 100_000).then("<100 K")
+             .when(pl.col("ecMaxContribution") < 500_000).then("100 K–500 K")
+             .when(pl.col("ecMaxContribution") < 1_000_000).then("500 K–1 M")
+             .when(pl.col("ecMaxContribution") < 5_000_000).then("1 M–5 M")
+             .when(pl.col("ecMaxContribution") < 10_000_000).then("5 M–10 M")
+             .otherwise("≥10 M")
+             .alias("funding_range")
+        )
+        .group_by("funding_range")
+        .agg(pl.count().alias("count"))
+        .sort("funding_range")
+        .collect()
+    )
+    fr_labels = fund_range["funding_range"].to_list()
+    fr_counts = fund_range["count"].to_list()
+
+    # 6) Projects per Country (Doughnut)
+    country = (
+        df
+        .explode("list_country")
+        .group_by("list_country")
+        .agg(pl.count().alias("count"))
+        .sort("count", descending=True)
+        .head(10)
+        .collect()
     )
-    years, counts = grouped["year"].to_list(), grouped["count"].to_list()
+    country_labels = country["list_country"].to_list()
+    country_counts = country["count"].to_list()
 
-    # Return data ready for frontend charts
     return {
-        "Projects per Year":    {"labels": years, "values": counts},
-        "Projects per Year 2":  {"labels": years, "values": counts},
-        "Projects per Year 3":  {"labels": years, "values": counts},
-        "Projects per Year 4":  {"labels": years, "values": counts},
-        "Projects per Year 5":  {"labels": years, "values": counts},
-        "Projects per Year 6":  {"labels": years, "values": counts},
+        "Projects per Year":          {"labels": years,          "values": year_counts},
+        "Project-Size Distribution":  {"labels": size_labels,    "values": size_counts},
+        "Co-funding Ratio by Scheme": {"labels": scheme_labels,  "values": scheme_values},
+        "Top 10 Topics (€ M)":        {"labels": topic_labels,   "values": topic_values},
+        "Funding Range Breakdown":    {"labels": fr_labels,      "values": fr_counts},
+        "Projects per Country":       {"labels": country_labels, "values": country_counts},
     }
 
 @app.get("/api/project/{project_id}/organizations")

backend/requirements.txt

@@ -15,9 +15,9 @@ google-cloud-storage==2.11.0
 
 # RAG & embeddings
 pytorch-lightning==2.5.1
-langchain
-langchain-huggingface
-sentence-transformers
+langchain==0.3.25
+langchain-huggingface==0.2.0
+sentence-transformers==4.1.0
 langchain-community==0.3.24
 
 # Vector store
@@ -27,31 +27,31 @@ faiss-cpu==1.11.0
 whoosh==2.7.4
 
 # Transformers
-torch>=2.6.0
+torch==2.7.0
 blobfile>=1.5.0
 tiktoken>=0.4.0
 sentencepiece==0.2.0
-transformers
-torchvision
-sympy>=1.13.1
-peft
+transformers==4.62.3
+torchvision==0.22.0
+sympy==1.14.0
+peft==0.15.2
 
 aiofiles==24.1.0
 optimum==1.25.3
 bitsandbytes==0.45.5
-hf_xet
-HuggingFace
-huggingface_hub
-huggingface_hub[hf_xet]
+hf_xet==1.1.2
+HuggingFace==0.0.1
+huggingface_hub==0.32.1
+huggingface_hub[hf_xet]==0.32.1
 
 # ————————————————————————————————————————————————
-
-joblib
-shap
-matplotlib
-scipy
-scikit-learn
-imbalanced-learn
-xgboost
-evidently
-optuna
+# Predictive modeling
+joblib==1.5.1
+shap==0.47.2
+matplotlib==3.10.3
+scipy==1.15.3
+scikit-learn==1.6.1
+imbalanced-learn==0.13.0
+xgboost==3.0.2
+evidently==0.7.6
+optuna==4.3.0

frontend/src/components/Dashboard.tsx

@@ -25,8 +25,10 @@ import {
   LineElement,
   PointElement,
   RadialLinearScale,
+  type ChartData,
+  type ChartOptions
 } from "chart.js";
-import { Bar, Pie, Doughnut, Line, Radar, PolarArea } from "react-chartjs-2";
+import { Bar, Pie, Doughnut, Line } from "react-chartjs-2";
 import type { FilterState, AvailableFilters } from "../hooks/types";
 
 // register chart components
@@ -43,16 +45,30 @@ ChartJS.register(
   RadialLinearScale
 );
 
-interface ChartData { labels: string[]; values: number[]; }
-interface Stats { [key: string]: ChartData; }
+type LegendPosition = "top" | "bottom" | "left" | "right" | "chartArea";
+interface ChartDataShape { labels: string[]; values: number[]; }
+interface Stats { [key: string]: ChartDataShape; }
+
+// define the six charts and their component types
+const chartOrder: { key: string; type: ChartType }[] = [
+  { key: "Projects per Year",          type: "line"     },
+  { key: "Project-Size Distribution",  type: "bar"      },
+  { key: "Co-funding Ratio by Scheme", type: "bar"      },
+  { key: "Top 10 Topics (€ M)",        type: "bar"      },
+  { key: "Funding Range Breakdown",    type: "pie"      },
+  { key: "Projects per Country",       type: "doughnut" },
+];
 
 const FILTER_LABELS: Record<keyof FilterState, string> = {
   status:       "Status",
   organization: "Organization",
   country:      "Country",
   legalBasis:   "Legal Basis",
+  topics:       "Topics",
 };
 
+type ChartType = "bar" | "pie" | "doughnut" | "line";
+
 interface DashboardProps {
   stats: Stats;
   filters: FilterState;
@@ -60,9 +76,6 @@ interface DashboardProps {
   availableFilters: AvailableFilters;
 }
 
-const chartTypes = ["bar","pie","doughnut","line","radar","polarArea"] as const;
-type ChartType = typeof chartTypes[number];
-
 const Dashboard: React.FC<DashboardProps> = ({
   stats: initialStats,
   filters,
@@ -104,7 +117,7 @@ const Dashboard: React.FC<DashboardProps> = ({
     setFilters(prev => ({ ...prev, [k1]: String(min), [k2]: String(max) }));
 
   const filterKeys: Array<keyof FilterState> = [
-    'status', 'organization', 'country', 'legalBasis'
+    'status', 'organization', 'country', 'legalBasis','topics'
   ];
 
   if (loadingStats && !Object.keys(statsData).length) {
@@ -121,7 +134,8 @@ const Dashboard: React.FC<DashboardProps> = ({
               key === 'status' ? 'statuses'
               : key === 'organization' ? 'organizations'
               : key === 'country' ? 'countries'
-              : 'legalBases'
+              : key === "legalBasis" ? "legalBases"
+              : 'topics'
             ] || [];
             const isOrg = key === 'organization';
             return (
@@ -201,23 +215,135 @@ const Dashboard: React.FC<DashboardProps> = ({
         </Flex>
       )}
       <SimpleGrid columns={{ base:1, md:2, lg:3 }} spacing={6}>
-        {Object.entries(statsData).map(([label, data], idx) => {
-          const type = chartTypes[idx % chartTypes.length] as ChartType;
-          const chartProps = {
-            data: { labels: data.labels, datasets: [{ label, data: data.values, backgroundColor: "#003399", borderColor: "#FFCC00", borderWidth: 1 }] },
-            options: { responsive: true, plugins: { legend: { position: "top" as const }, title: { display: true, text: label } } }
-          };
-
-          return (
-            <Box key={label} bg="white" borderRadius="md" p={4}>
-              {type === "bar"       && <Bar {...chartProps} />}
-              {type === "pie"       && <Pie {...chartProps} />}
-              {type === "doughnut"  && <Doughnut {...chartProps} />}
-              {type === "line"      && <Line {...chartProps} />}
-              {type === "radar"     && <Radar {...chartProps} />}
-              {type === "polarArea" && <PolarArea {...chartProps} />}
-            </Box>
-          );
+        {chartOrder.map(({ key, type }) => {
+          const raw = statsData[key]!;
+
+          // ---- properly typed Chart.js data & options ----
+          if (type === "bar") {
+            const data: ChartData<"bar", number[], string> = {
+              labels: raw.labels,
+              datasets: [
+                {
+                  label: key,
+                  data: raw.values,
+                  backgroundColor: "#003399",
+                  borderColor: "#FFCC00",
+                  borderWidth: 1,
+                },
+              ],
+            };
+            const options: ChartOptions<"bar"> = {
+              responsive: true,
+              plugins: {
+                legend: {
+                  position: "top" as LegendPosition,
+                },
+                title: {
+                  display: true,
+                  text: key,
+                },
+              },
+            };
+            return (
+              <Box key={key} bg="white" borderRadius="md" p={4}>
+                <Bar data={data} options={options} />
+              </Box>
+            );
+          }
+          if (type === "line") {
+            const data: ChartData<"line", number[], string> = {
+              labels: raw.labels,
+              datasets: [
+                {
+                  label: key,
+                  data: raw.values,
+                  backgroundColor: "#003399",
+                  borderColor: "#FFCC00",
+                  borderWidth: 1,
+                },
+              ],
+            };
+            const options: ChartOptions<"line"> = {
+              responsive: true,
+              plugins: {
+                legend: {
+                  position: "top" as LegendPosition,
+                },
+                title: {
+                  display: true,
+                  text: key,
+                },
+              },
+            };
+            return (
+              <Box key={key} bg="white" borderRadius="md" p={4}>
+                <Line data={data} options={options} />
+              </Box>
+            );
+          }
+          if (type === "pie") {
+            const data: ChartData<"pie", number[], string> = {
+              labels: raw.labels,
+              datasets: [
+                {
+                  label: key,
+                  data: raw.values,
+                  backgroundColor: "#003399",
+                  borderColor: "#FFCC00",
+                  borderWidth: 1,
+                },
+              ],
+            };
+            const options: ChartOptions<"pie"> = {
+              responsive: true,
+              plugins: {
+                legend: {
+                  position: "top" as LegendPosition,
+                },
+                title: {
+                  display: true,
+                  text: key,
+                },
+              },
+            };
+            return (
+              <Box key={key} bg="white" borderRadius="md" p={4}>
+                <Pie data={data} options={options} />
+              </Box>
+            );
+          }
+          if (type === "doughnut") {
+            const data: ChartData<"doughnut", number[], string> = {
+              labels: raw.labels,
+              datasets: [
+                {
+                  label: key,
+                  data: raw.values,
+                  backgroundColor: "#003399",
+                  borderColor: "#FFCC00",
+                  borderWidth: 1,
+                },
+              ],
+            };
+            const options: ChartOptions<"doughnut"> = {
+              responsive: true,
+              plugins: {
+                legend: {
+                  position: "top" as LegendPosition,
+                },
+                title: {
+                  display: true,
+                  text: key,
+                },
+              },
+            };
+            return (
+              <Box key={key} bg="white" borderRadius="md" p={4}>
+                <Doughnut data={data} options={options} />
+              </Box>
+            );
+          }
+          return null;
         })}
       </SimpleGrid>
     </Box>

frontend/src/components/ProjectExplorer.tsx

@@ -27,6 +27,7 @@ interface FilterOptions {
   countries: string[];
   fundingSchemes: string[];
   ids: string[];
+  topics: string[];
 }
 const MIN_SEARCH_LEN = 3;
 
@@ -51,6 +52,8 @@ const ProjectExplorer: React.FC<ProjectExplorerProps> = ({
   setFundingSchemeFilter,
   idFilter,
   setIdFilter,
+  topicsFilter,
+  setTopicsFilter,
   setSortField,
   sortField,
   setSortOrder,
@@ -72,6 +75,7 @@ const ProjectExplorer: React.FC<ProjectExplorerProps> = ({
     countries: [],
     fundingSchemes: [],
     ids: [],
+    topics: [],
   });
   const [loadingFilters, setLoadingFilters] = useState(false);
 
@@ -86,6 +90,7 @@ const ProjectExplorer: React.FC<ProjectExplorerProps> = ({
     if (search.length >= MIN_SEARCH_LEN) params.set("search", search);
     if (idFilter.length >= MIN_SEARCH_LEN) params.set("proj_id", idFilter);
     if (fundingSchemeFilter)   params.set("fundingScheme", fundingSchemeFilter);
+    if (topicsFilter)          params.set("topics", topicsFilter);
     params.set("sortField",     sortField);
     params.set("sortOrder",     sortOrder);
 
@@ -102,6 +107,7 @@ const ProjectExplorer: React.FC<ProjectExplorerProps> = ({
     search,
     idFilter,
     fundingSchemeFilter,
+    topicsFilter,
     sortField,
     sortOrder,
   ]);
@@ -189,6 +195,15 @@ const ProjectExplorer: React.FC<ProjectExplorerProps> = ({
           >
             {filterOpts.fundingSchemes.map((c) => <option key={c} value={c}>{c}</option>)}
           </ChakraSelect>
+          <ChakraSelect
+            placeholder={loadingFilters ? "Loading..." : "Funding Scheme"}
+            value={topicsFilter}
+            onChange={(e) => { setTopicsFilter(e.target.value); setPage(0); }}
+            isDisabled={loadingFilters}
+            width="180px"
+          >
+            {filterOpts.topics.map((c) => <option key={c} value={c}>{c}</option>)}
+          </ChakraSelect>
         </Flex>
 
         <Box

frontend/src/hooks/types.ts

@@ -22,11 +22,6 @@ export interface Project {
 
 export interface ProjectDetailsProps {
   project: Project;
-//  question: string;
-//  setQuestion: React.Dispatch<React.SetStateAction<string>>;
-//  askChatbot: () => void;
-//  chatHistory: ChatMessage[];
-//  messagesEndRef: React.RefObject<HTMLDivElement>;
 }
 
 
@@ -57,6 +52,7 @@ export interface FilterState {
   organization: string;
   country: string;
   legalBasis: string;
+  topics: string;
   minYear: string;
   maxYear: string;
   minFunding: string;
@@ -77,6 +73,7 @@ export interface AvailableFilters {
   legalBases: string[];
   fundingSchemes: string[];
   ids: string[];
+  topics: string[];
 }
 
 export interface ProjectExplorerProps {
@@ -95,6 +92,8 @@ export interface ProjectExplorerProps {
   setFundingSchemeFilter: (value: string) => void;
   idFilter: string;
   setIdFilter: (value: string) => void;
+  topicsFilter: string;
+  setTopicsFilter: (value: string) => void;
   setSortField: (field: string) => void;
   sortField: string;
   setSortOrder : (order: "asc" | "desc") => void;

frontend/src/hooks/useAppState.ts

@@ -24,6 +24,7 @@ export const useAppState = () => {
   const [countryFilter, setCountryFilter] = useState('');
   const [fundingSchemeFilter, setFundingSchemeFilter ] = useState('');
   const [idFilter, setIdFilter] = useState('');
+  const [topicsFilter, setTopicsFilter] = useState('');
   const [sortField, setSortField] = useState('');
   const [sortOrder, setSortOrder] = useState<SortOrder>("asc");
   const [filters, setFilters] = useState<FilterState>({
@@ -31,6 +32,7 @@ export const useAppState = () => {
     organization: "",
     country: "",
     legalBasis: "",
+    topics: "",
     minYear: "2000",
     maxYear: "2025",
     minFunding: "0",
@@ -46,13 +48,14 @@ export const useAppState = () => {
     countries: [],
     legalBases: [],
     fundingSchemes:[],
-    ids:[]
+    ids:[],
+    topics: []
   });
 
   const messagesEndRef = useRef<HTMLDivElement | null>(null);
 
   const fetchProjects = () => {
-    fetch(`/api/projects?page=${page}&search=${encodeURIComponent(search)}&status=${statusFilter}&legalBasis=${legalFilter}&organization=${orgFilter}&country=${countryFilter}&fundingScheme=${fundingSchemeFilter}&proj_id=${idFilter}&sortField=${sortField}&sortOrder=${sortOrder}`)
+    fetch(`/api/projects?page=${page}&search=${encodeURIComponent(search)}&status=${statusFilter}&legalBasis=${legalFilter}&organization=${orgFilter}&country=${countryFilter}&fundingScheme=${fundingSchemeFilter}&proj_id=${idFilter}&topic=${topicsFilter}&sortField=${sortField}&sortOrder=${sortOrder}`)
       .then(res => res.json())
       .then((data: Project[]) => setProjects(data))
       .catch(console.error);
@@ -77,7 +80,8 @@ export const useAppState = () => {
           countries: data.countries,
           legalBases: data.legalBases,
           fundingSchemes: data.fundingSchemes,
-          ids: []
+          ids: [],
+          topics: data.topics
         });
       });
   };